/* =========================================================
FILE MANAGER — CLIENT SPA
=========================================================
Architecture:
- RSA-OAEP + AES-256-GCM hybrid encryption via Web Crypto API
- No cookies / sessionStorage — token lives in module-scoped memory
- Token is sent as Bearer header on every API call
- Fingerprint (derived from navigator info) locks the token to this browser
========================================================= */
'use strict';
// ───────────────────────────────────────────────────────────────────────────
// STATE
// ───────────────────────────────────────────────────────────────────────────
const STATE = {
token: null, // decrypted JWT string
username: null,
isAdmin: false,
permissions: {},
roots: [], // [{ label, path }]
currentDir: null, // absolute path currently shown (null = roots view)
currentRoot: null, // { label, path } of the active root
items: [], // current directory listing
selectedItem: null, // item object selected in sidebar
// Ephemeral key pair per session (client-side)
clientPrivateKey: null,
clientPublicKeyJwk: null,
// Server public key for encrypting login
serverPublicKeyJwk: null,
};
// ───────────────────────────────────────────────────────────────────────────
// CRYPTO HELPERS (Web Crypto API)
// ───────────────────────────────────────────────────────────────────────────
async function generateClientKeyPair() {
const kp = await crypto.subtle.generateKey(
{ name: 'RSA-OAEP', modulusLength: 2048, publicExponent: new Uint8Array([1,0,1]), hash: 'SHA-256' },
true,
['encrypt', 'decrypt'],
);
STATE.clientPrivateKey = kp.privateKey;
STATE.clientPublicKeyJwk = await crypto.subtle.exportKey('jwk', kp.publicKey);
}
/**
* Hybrid-encrypt a JS object using the server's RSA public key.
* Returns { encryptedKey, iv, ciphertext, tag } all as base64 strings.
*/
async function hybridEncryptForServer(obj) {
const serverPub = await crypto.subtle.importKey(
'jwk', STATE.serverPublicKeyJwk,
{ name: 'RSA-OAEP', hash: 'SHA-256' },
false, ['encrypt'],
);
const plaintext = new TextEncoder().encode(JSON.stringify(obj));
const aesKey = await crypto.subtle.generateKey({ name: 'AES-GCM', length: 256 }, true, ['encrypt']);
const iv = crypto.getRandomValues(new Uint8Array(12));
const gcmResult = await crypto.subtle.encrypt({ name: 'AES-GCM', iv }, aesKey, plaintext);
// gcmResult = ciphertext || tag (last 16 bytes are auth tag)
const gcmBytes = new Uint8Array(gcmResult);
const ciphertext = gcmBytes.slice(0, gcmBytes.length - 16);
const tag = gcmBytes.slice(gcmBytes.length - 16);
const rawAes = await crypto.subtle.exportKey('raw', aesKey);
const encryptedKey = await crypto.subtle.encrypt({ name: 'RSA-OAEP' }, serverPub, rawAes);
return {
encryptedKey: b64(encryptedKey),
iv: b64(iv),
ciphertext: b64(ciphertext),
tag: b64(tag),
};
}
/**
* Hybrid-decrypt a payload encrypted by the server for us (using our public key).
*/
async function hybridDecryptFromServer(payload) {
const encryptedKey = unb64(payload.encryptedKey);
const iv = unb64(payload.iv);
const ciphertext = unb64(payload.ciphertext);
const tag = unb64(payload.tag);
const rawAes = await crypto.subtle.decrypt(
{ name: 'RSA-OAEP' }, STATE.clientPrivateKey, encryptedKey,
);
const aesKey = await crypto.subtle.importKey('raw', rawAes, { name: 'AES-GCM' }, false, ['decrypt']);
// Recombine ciphertext + tag for AES-GCM
const combined = new Uint8Array(ciphertext.byteLength + tag.byteLength);
combined.set(new Uint8Array(ciphertext));
combined.set(new Uint8Array(tag), ciphertext.byteLength);
const plain = await crypto.subtle.decrypt({ name: 'AES-GCM', iv }, aesKey, combined);
return new TextDecoder().decode(plain);
}
// ───────────────────────────────────────────────────────────────────────────
// UTIL
// ───────────────────────────────────────────────────────────────────────────
function b64(buf) {
return btoa(String.fromCharCode(...new Uint8Array(buf instanceof ArrayBuffer ? buf : buf.buffer)));
}
function unb64(str) {
const binary = atob(str);
const buf = new Uint8Array(binary.length);
for (let i = 0; i < binary.length; i++) buf[i] = binary.charCodeAt(i);
return buf.buffer;
}
/** Stable browser fingerprint (not stored, derived fresh each load) */
function getFingerprint() {
const nav = navigator;
return [
nav.language,
nav.platform || nav.userAgentData?.platform || '',
nav.hardwareConcurrency,
screen.colorDepth,
screen.width + 'x' + screen.height,
Intl.DateTimeFormat().resolvedOptions().timeZone,
].join('|');
}
function formatBytes(bytes) {
if (bytes == null) return '—';
if (bytes < 1024) return bytes + ' B';
if (bytes < 1048576) return (bytes / 1024).toFixed(1) + ' KB';
if (bytes < 1073741824) return (bytes / 1048576).toFixed(1) + ' MB';
return (bytes / 1073741824).toFixed(2) + ' GB';
}
function extOf(name) {
const i = name.lastIndexOf('.');
return i >= 0 ? name.slice(i + 1).toLowerCase() : '';
}
// ───────────────────────────────────────────────────────────────────────────
// API
// ───────────────────────────────────────────────────────────────────────────
async function api(method, path, body, opts = {}) {
const headers = { 'Content-Type': 'application/json' };
if (STATE.token) {
headers['Authorization'] = 'Bearer ' + STATE.token;
headers['X-Fp'] = getFingerprint();
}
const res = await fetch('/api' + path, {
method,
headers,
body: body != null ? JSON.stringify(body) : undefined,
...opts,
});
if (!res.ok) {
const j = await res.json().catch(() => ({}));
// Session-expired → force re-login
if (res.status === 401) { logout(); return null; }
throw new Error(j.error || res.statusText);
}
return res.json();
}
// ───────────────────────────────────────────────────────────────────────────
// TOAST
// ───────────────────────────────────────────────────────────────────────────
function toast(msg, type = '') {
const el = document.createElement('div');
el.className = 'toast-msg' + (type ? ' ' + type : '');
el.textContent = msg;
document.getElementById('toast').appendChild(el);
setTimeout(() => el.remove(), 3500);
}
// ───────────────────────────────────────────────────────────────────────────
// AUTH FLOW
// ───────────────────────────────────────────────────────────────────────────
function showAuthOverlay(setupMode = false) {
document.getElementById('app').classList.add('hidden');
const overlay = document.getElementById('auth-overlay');
overlay.classList.remove('hidden');
document.getElementById('auth-title').textContent = setupMode ? 'Create Admin Account' : 'Sign In';
document.getElementById('auth-subtitle').classList.toggle('hidden', !setupMode);
document.getElementById('auth-submit').textContent = setupMode ? 'Create Account' : 'Sign In';
document.getElementById('auth-error').classList.add('hidden');
document.getElementById('auth-username').value = '';
document.getElementById('auth-password').value = '';
document.getElementById('auth-username').focus();
document.getElementById('auth-form').dataset.mode = setupMode ? 'setup' : 'login';
}
function showApp() {
document.getElementById('auth-overlay').classList.add('hidden');
document.getElementById('app').classList.remove('hidden');
document.getElementById('btn-admin').classList.toggle('hidden', !STATE.isAdmin);
}
async function initAuth() {
// Always generate a fresh key pair so each page-load session is independent
await generateClientKeyPair();
// Fetch server public key
const { publicKey } = await api('GET', '/auth/server-key').catch(() => ({ publicKey: null }));
if (!publicKey) { toast('Could not reach server.', 'err'); return; }
STATE.serverPublicKeyJwk = publicKey;
// Check whether first-run setup is needed
const { needed } = await api('GET', '/auth/setup-needed').catch(() => ({ needed: false }));
showAuthOverlay(needed);
}
async function doLogin(username, password, isSetup) {
const encrypted = await hybridEncryptForServer({ username, password });
const endpoint = isSetup ? '/auth/setup' : '/auth/login';
let data;
try {
data = await api('POST', endpoint, {
encrypted,
clientPublicKey: STATE.clientPublicKeyJwk,
fingerprint: getFingerprint(),
});
} catch (err) {
return err.message;
}
if (!data) return 'Login failed.';
// Decrypt the token sent back by the server
const token = await hybridDecryptFromServer(data.encrypted);
STATE.token = token;
// Load user info
const me = await api('GET', '/auth/me');
if (!me) return 'Session error.';
STATE.username = me.username;
STATE.isAdmin = me.isAdmin;
STATE.permissions = me.permissions;
showApp();
await loadRoots();
return null; // no error
}
function logout() {
STATE.token = null;
STATE.username = null;
STATE.isAdmin = false;
STATE.permissions = {};
STATE.currentDir = null;
STATE.currentRoot = null;
STATE.items = [];
closeSidebar();
initAuth();
}
// ───────────────────────────────────────────────────────────────────────────
// NAVIGATION
// ───────────────────────────────────────────────────────────────────────────
async function loadRoots() {
const data = await api('GET', '/files/roots');
if (!data) return;
STATE.roots = data.roots;
if (STATE.roots.length === 1) {
// Single root → open it directly
await navigateTo(STATE.roots[0].path, STATE.roots[0]);
} else {
renderRootsView();
}
}
function renderRootsView() {
STATE.currentDir = null;
STATE.currentRoot = null;
renderBreadcrumb();
const grid = document.getElementById('file-grid');
grid.innerHTML = '';
document.getElementById('empty-notice').classList.add('hidden');
closeSidebar();
for (const root of STATE.roots) {
const el = makeFileItem({ name: root.label, isDir: true, path: root.path, _root: root });
grid.appendChild(el);
}
}
async function navigateTo(absPath, root) {
if (root) STATE.currentRoot = root;
STATE.currentDir = absPath;
const data = await api('GET', `/files/list?dir=${encodeURIComponent(absPath)}`);
if (!data) return;
STATE.items = data.items;
renderBreadcrumb();
renderFileGrid();
closeSidebar();
}
function renderBreadcrumb() {
const nav = document.getElementById('breadcrumb');
nav.innerHTML = '';
// "Home" crumb
const home = document.createElement('span');
home.className = 'crumb' + (STATE.currentDir == null ? ' active' : '');
home.textContent = 'Home';
home.addEventListener('click', () => {
if (STATE.roots.length === 1) {
navigateTo(STATE.roots[0].path, STATE.roots[0]);
} else {
renderRootsView();
}
});
nav.appendChild(home);
if (!STATE.currentDir || !STATE.currentRoot) return;
// Build path segments relative to the root
const rootPath = STATE.currentRoot.path;
const relative = STATE.currentDir === rootPath
? ''
: STATE.currentDir.replace(rootPath, '').replace(/^[\\/]/, '');
const parts = [STATE.currentRoot.label, ...relative.split(/[\\/]/).filter(Boolean)];
let accumulated = rootPath;
for (let i = 0; i < parts.length; i++) {
const sep = document.createElement('span');
sep.className = 'sep';
sep.textContent = ' / ';
nav.appendChild(sep);
const crumb = document.createElement('span');
crumb.className = 'crumb' + (i === parts.length - 1 ? ' active' : '');
crumb.textContent = parts[i];
// Capture the path for this crumb
const capturedPath = i === 0 ? rootPath : accumulated;
if (i < parts.length - 1) {
crumb.addEventListener('click', () => navigateTo(capturedPath, STATE.currentRoot));
}
nav.appendChild(crumb);
// Advance accumulated path (skip for root label)
if (i > 0) accumulated = accumulated + '/' + parts[i];
else if (i === 0 && parts.length > 1) {
// After root label, next crumb should append the next segment
accumulated = rootPath;
}
}
}
// ───────────────────────────────────────────────────────────────────────────
// FILE GRID RENDERING
// ───────────────────────────────────────────────────────────────────────────
function renderFileGrid() {
const grid = document.getElementById('file-grid');
grid.innerHTML = '';
const empty = document.getElementById('empty-notice');
const sorted = [...STATE.items].sort((a, b) => {
if (a.isDir !== b.isDir) return a.isDir ? -1 : 1;
return a.name.localeCompare(b.name);
});
empty.classList.toggle('hidden', sorted.length > 0);
for (const item of sorted) {
grid.appendChild(makeFileItem(item));
}
}
function makeFileItem(item) {
const el = document.createElement('div');
el.className = 'file-item';
el.dataset.path = item.path;
const icon = document.createElement('div');
icon.className = 'icon';
icon.innerHTML = item.isDir ? iconFolder() : iconFile(item.name);
el.appendChild(icon);
const name = document.createElement('div');
name.className = 'name';
name.textContent = item.name;
el.appendChild(name);
// Single-click: open sidebar
el.addEventListener('click', (e) => {
e.stopPropagation();
if (item._root) {
// Clicking a root tile goes straight in
navigateTo(item.path, item._root);
return;
}
selectItem(el, item);
});
// Double-click: enter folder or view/download file
el.addEventListener('dblclick', (e) => {
e.stopPropagation();
if (item.isDir) {
navigateTo(item.path, STATE.currentRoot);
} else {
downloadOrView(item);
}
});
return el;
}
function selectItem(el, item) {
document.querySelectorAll('.file-item.selected').forEach(e => e.classList.remove('selected'));
el.classList.add('selected');
STATE.selectedItem = item;
openSidebar(item);
}
// ───────────────────────────────────────────────────────────────────────────
// SIDEBAR
// ───────────────────────────────────────────────────────────────────────────
async function openSidebar(item) {
const sidebar = document.getElementById('sidebar');
sidebar.classList.remove('hidden');
document.getElementById('app').classList.add('sidebar-open');
document.getElementById('sidebar-icon').innerHTML = item.isDir ? iconFolder(64) : iconFile(item.name, 64);
document.getElementById('sidebar-name').textContent = item.name;
// Load metadata
const dl = document.getElementById('sidebar-meta');
dl.innerHTML = '
Loading…';
const actions = document.getElementById('sidebar-actions');
actions.innerHTML = '';
if (!item.isDir) {
const meta = await api('GET', `/files/meta?file=${encodeURIComponent(item.path)}`);
if (meta) {
dl.innerHTML = `
Size ${formatBytes(meta.size)}
Modified ${new Date(meta.mtime).toLocaleString()}
Uploaded by${meta.uploader || '—'}
Downloaded by${meta.downloaders.join(', ') || '—'}
`;
}
// View / download button
const btnDl = document.createElement('button');
btnDl.textContent = 'View / Download';
btnDl.addEventListener('click', () => downloadOrView(item));
actions.appendChild(btnDl);
} else {
dl.innerHTML = `TypeFolder`;
const btnOpen = document.createElement('button');
btnOpen.textContent = 'Open folder';
btnOpen.addEventListener('click', () => navigateTo(item.path, STATE.currentRoot));
actions.appendChild(btnOpen);
}
// Rename button (write access required)
if (canWrite()) {
const btnRen = document.createElement('button');
btnRen.textContent = 'Rename';
btnRen.addEventListener('click', () => openRenameModal(item));
actions.appendChild(btnRen);
const btnDel = document.createElement('button');
btnDel.textContent = 'Delete';
btnDel.className = 'danger';
btnDel.addEventListener('click', () => deleteItem(item));
actions.appendChild(btnDel);
}
}
function closeSidebar() {
document.getElementById('sidebar').classList.add('hidden');
document.getElementById('app').classList.remove('sidebar-open');
document.querySelectorAll('.file-item.selected').forEach(e => e.classList.remove('selected'));
STATE.selectedItem = null;
}
// ───────────────────────────────────────────────────────────────────────────
// DOWNLOAD / VIEW
// ───────────────────────────────────────────────────────────────────────────
function downloadOrView(item) {
const url = `/api/files/download?file=${encodeURIComponent(item.path)}`;
// Open in new tab — browser decides whether to display or download
const a = document.createElement('a');
a.href = url;
a.target = '_blank';
a.rel = 'noopener noreferrer';
// We need to send the auth header; since can't do that, we fetch and blob it
fetchAndServe(item, url);
}
async function fetchAndServe(item, url) {
try {
const res = await fetch(url, {
headers: {
Authorization: 'Bearer ' + STATE.token,
'X-Fp': getFingerprint(),
},
});
if (!res.ok) { toast('Download failed.', 'err'); return; }
const blob = await res.blob();
const objUrl = URL.createObjectURL(blob);
const a = document.createElement('a');
a.href = objUrl;
a.download = item.name;
// Try to open viewable types inline
const viewable = /^(image|video|audio|text|application\/pdf)/.test(blob.type);
if (viewable) {
window.open(objUrl, '_blank', 'noopener,noreferrer');
} else {
a.click();
}
setTimeout(() => URL.revokeObjectURL(objUrl), 60000);
} catch {
toast('Download failed.', 'err');
}
}
// ───────────────────────────────────────────────────────────────────────────
// UPLOAD
// ───────────────────────────────────────────────────────────────────────────
function canWrite() {
if (STATE.isAdmin) return true;
if (!STATE.currentRoot) return false;
const p = STATE.permissions[STATE.currentRoot.label];
return p && p.write;
}
async function uploadFiles(fileList) {
if (!STATE.currentDir) { toast('Open a folder first.', 'err'); return; }
if (!canWrite()) { toast('No write access.', 'err'); return; }
const formData = new FormData();
for (const f of fileList) formData.append('files', f);
// Show upload bar
const wrap = document.createElement('div');
wrap.className = 'upload-bar-wrap';
wrap.innerHTML = `Uploading ${fileList.length} file(s)…`;
document.body.appendChild(wrap);
try {
const xhr = new XMLHttpRequest();
xhr.open('POST', `/api/files/upload?dir=${encodeURIComponent(STATE.currentDir)}`);
xhr.setRequestHeader('Authorization', 'Bearer ' + STATE.token);
xhr.setRequestHeader('X-Fp', getFingerprint());
xhr.upload.addEventListener('progress', e => {
if (e.lengthComputable) {
wrap.querySelector('.upload-bar-fill').style.width = (e.loaded / e.total * 100) + '%';
}
});
await new Promise((resolve, reject) => {
xhr.onload = () => {
if (xhr.status === 200) resolve();
else reject(new Error(JSON.parse(xhr.responseText).error || 'Upload failed'));
};
xhr.onerror = () => reject(new Error('Network error'));
xhr.send(formData);
});
toast(`Uploaded ${fileList.length} file(s).`, 'ok');
await navigateTo(STATE.currentDir, STATE.currentRoot);
} catch (err) {
toast(err.message, 'err');
} finally {
wrap.remove();
}
}
// ───────────────────────────────────────────────────────────────────────────
// FOLDER DRAG-AND-DROP (recursive)
// ───────────────────────────────────────────────────────────────────────────
/**
* Reads all readEntries batches from a DirectoryReader (browsers may return
* results in chunks; we must keep calling until we get an empty array).
*/
function readAllEntries(reader) {
return new Promise((resolve, reject) => {
const all = [];
function next() {
reader.readEntries(batch => {
if (!batch.length) { resolve(all); return; }
all.push(...batch);
next();
}, reject);
}
next();
});
}
/**
* Recursively walk a FileSystemEntry tree, creating server-side directories
* on the fly and collecting { file, targetDir } pairs for upload.
*/
async function collectEntries(entry, serverDir, toUpload) {
if (entry.isFile) {
const file = await new Promise((res, rej) => entry.getFile(res, rej));
toUpload.push({ file, targetDir: serverDir });
} else if (entry.isDirectory) {
// Ask the server to create the directory; it returns the canonical path.
let newServerDir;
try {
const resp = await api('POST', '/files/mkdir', { dir: serverDir, name: entry.name });
newServerDir = resp.path;
} catch {
// Directory may already exist — reconstruct path from what we know.
// The server always returns JSON with {error} on failure, so we can
// still continue by falling back to a best-effort path join.
// We rely on the fact that the server separator is consistent within
// a session (the list/browse API already returned paths in that format).
const sep = serverDir.includes('\\') ? '\\' : '/';
newServerDir = serverDir + sep + entry.name;
}
const reader = entry.createReader();
const subEntries = await readAllEntries(reader);
for (const sub of subEntries) {
await collectEntries(sub, newServerDir, toUpload);
}
}
}
async function uploadEntries(entries) {
if (!STATE.currentDir) { toast('Open a folder first.', 'err'); return; }
if (!canWrite()) { toast('No write access.', 'err'); return; }
const wrap = document.createElement('div');
wrap.className = 'upload-bar-wrap';
wrap.innerHTML = `Scanning…`;
document.body.appendChild(wrap);
try {
const toUpload = [];
for (const entry of entries) {
await collectEntries(entry, STATE.currentDir, toUpload);
}
if (!toUpload.length) { toast('No files found.', 'err'); return; }
let done = 0;
const total = toUpload.length;
const updateBar = () => {
wrap.querySelector('span').textContent = `Uploading ${done} / ${total} file(s)…`;
wrap.querySelector('.upload-bar-fill').style.width = (done / total * 100) + '%';
};
updateBar();
for (const { file, targetDir } of toUpload) {
const formData = new FormData();
formData.append('files', file);
await new Promise((resolve, reject) => {
const xhr = new XMLHttpRequest();
xhr.open('POST', `/api/files/upload?dir=${encodeURIComponent(targetDir)}`);
xhr.setRequestHeader('Authorization', 'Bearer ' + STATE.token);
xhr.setRequestHeader('X-Fp', getFingerprint());
xhr.onload = () => xhr.status === 200
? resolve()
: reject(new Error((JSON.parse(xhr.responseText) || {}).error || 'Upload failed'));
xhr.onerror = () => reject(new Error('Network error'));
xhr.send(formData);
});
done++;
updateBar();
}
toast(`Uploaded ${total} file(s).`, 'ok');
await navigateTo(STATE.currentDir, STATE.currentRoot);
} catch (err) {
toast(err.message, 'err');
} finally {
wrap.remove();
}
}
// DRAG-AND-DROP
// ───────────────────────────────────────────────────────────────────────────
function initDragDrop() {
const main = document.getElementById('main-content');
const dropOvl = document.getElementById('drop-overlay');
let dragDepth = 0;
main.addEventListener('dragenter', e => {
e.preventDefault();
dragDepth++;
dropOvl.classList.remove('hidden');
});
main.addEventListener('dragleave', () => {
dragDepth--;
if (dragDepth <= 0) { dragDepth = 0; dropOvl.classList.add('hidden'); }
});
main.addEventListener('dragover', e => e.preventDefault());
main.addEventListener('drop', async e => {
e.preventDefault();
dragDepth = 0;
dropOvl.classList.add('hidden');
if (!canWrite()) { toast('No write access.', 'err'); return; }
const items = Array.from(e.dataTransfer.items || []);
// Use the FileSystem Entry API when available so we can handle folders.
if (items.length && typeof items[0].webkitGetAsEntry === 'function') {
const entries = items.map(i => i.webkitGetAsEntry()).filter(Boolean);
if (entries.some(en => en.isDirectory)) {
await uploadEntries(entries);
return;
}
}
// Plain files only — use the fast batch path.
const files = e.dataTransfer.files;
if (files.length) await uploadFiles(files);
});
}
// ───────────────────────────────────────────────────────────────────────────
// RENAME
// ───────────────────────────────────────────────────────────────────────────
function openRenameModal(item) {
const modal = document.getElementById('rename-modal');
modal.classList.remove('hidden');
const input = document.getElementById('rename-input');
input.value = item.name;
input.focus();
input.select();
document.getElementById('rename-error').classList.add('hidden');
document.getElementById('rename-form').onsubmit = async (e) => {
e.preventDefault();
const newName = input.value.trim();
if (!newName) return;
try {
await api('POST', '/files/rename', { from: item.path, to: newName });
modal.classList.add('hidden');
toast('Renamed.', 'ok');
await navigateTo(STATE.currentDir, STATE.currentRoot);
} catch (err) {
document.getElementById('rename-error').textContent = err.message;
document.getElementById('rename-error').classList.remove('hidden');
}
};
}
// ───────────────────────────────────────────────────────────────────────────
// DELETE
// ───────────────────────────────────────────────────────────────────────────
async function deleteItem(item) {
if (!confirm(`Delete "${item.name}"? This cannot be undone.`)) return;
try {
await api('POST', '/files/delete', { path: item.path });
toast('Deleted.', 'ok');
closeSidebar();
await navigateTo(STATE.currentDir, STATE.currentRoot);
} catch (err) {
toast(err.message, 'err');
}
}
// ───────────────────────────────────────────────────────────────────────────
// ADMIN PANEL
// ───────────────────────────────────────────────────────────────────────────
async function openAdminModal() {
document.getElementById('admin-modal').classList.remove('hidden');
await refreshAdminConfig();
await refreshAdminUsers();
}
async function refreshAdminConfig() {
const data = await api('GET', '/admin/config');
if (!data) return;
const container = document.getElementById('admin-paths');
container.innerHTML = '';
for (const p of data.paths) {
const row = document.createElement('div');
row.className = 'path-row';
row.innerHTML = `${p}`;
row.querySelector('button').addEventListener('click', () => {
row.remove();
});
container.appendChild(row);
}
}
async function refreshAdminUsers() {
const data = await api('GET', '/admin/users');
if (!data) return;
const container = document.getElementById('admin-users-list');
container.innerHTML = '';
// Need paths for permission rows
const cfg = await api('GET', '/admin/config');
const paths = cfg ? (cfg.effectivePaths || []) : [];
for (const u of data.users) {
const row = document.createElement('div');
row.className = 'user-row';
row.innerHTML = `
${u.username}
${u.isAdmin ? 'Admin' : ''}
`;
row.querySelector('[data-action="edit"]').addEventListener('click', () =>
openUserModal(u, paths));
row.querySelector('[data-action="delete"]').addEventListener('click', async () => {
if (!confirm(`Delete user "${u.username}"?`)) return;
try {
await api('DELETE', `/admin/users/${u.id}`);
toast('User deleted.', 'ok');
await refreshAdminUsers();
} catch (err) { toast(err.message, 'err'); }
});
container.appendChild(row);
}
}
function openUserModal(user, paths) {
const modal = document.getElementById('user-modal');
modal.classList.remove('hidden');
document.getElementById('user-modal-title').textContent = user ? `Edit: ${user.username}` : 'New User';
document.getElementById('user-error').classList.add('hidden');
const usernameInput = document.getElementById('user-username');
usernameInput.value = user ? user.username : '';
usernameInput.readOnly = !!user;
document.getElementById('user-password').value = '';
document.getElementById('user-is-admin').checked = user ? user.isAdmin : false;
// Password placeholder
document.getElementById('user-password').placeholder =
user ? 'Leave blank to keep current' : 'Min 8 characters';
// Build permissions grid
const permDiv = document.getElementById('user-permissions');
permDiv.innerHTML = '';
if (paths.length) {
const heading = document.createElement('h4');
heading.textContent = 'Path Permissions';
permDiv.appendChild(heading);
const isAdminUser = !!(user && user.isAdmin);
// Mirror the is-admin checkbox so toggling it live-updates the perm rows.
const adminChk = document.getElementById('user-is-admin');
const rebuildPermRows = (admin) => {
permDiv.querySelectorAll('.perm-row').forEach(r => {
r.querySelectorAll('input[type=checkbox]').forEach(cb => {
cb.disabled = admin;
if (admin) cb.checked = true;
});
r.title = admin ? 'Admins always have full access' : '';
});
};
adminChk.addEventListener('change', () => rebuildPermRows(adminChk.checked));
for (const p of paths) {
const label = p.split(/[\\/]/).pop();
const perms = user && user.permissions ? (user.permissions[label] || {}) : {};
const row = document.createElement('div');
row.className = 'perm-row';
const readChecked = isAdminUser || perms.read;
const writeChecked = isAdminUser || perms.write;
row.innerHTML = `
${label}
`;
if (isAdminUser) row.title = 'Admins always have full access';
permDiv.appendChild(row);
}
}
document.getElementById('user-form').onsubmit = async (e) => {
e.preventDefault();
const password = document.getElementById('user-password').value;
const isAdmin = document.getElementById('user-is-admin').checked;
const permissions = {};
permDiv.querySelectorAll('input[data-label]').forEach(cb => {
const lbl = cb.dataset.label;
if (!permissions[lbl]) permissions[lbl] = {};
permissions[lbl][cb.dataset.type] = cb.checked;
});
try {
if (user) {
const body = { isAdmin, permissions };
if (password) body.password = password;
await api('PATCH', `/admin/users/${user.id}`, body);
} else {
const uname = document.getElementById('user-username').value.trim();
await api('POST', '/admin/users', { username: uname, password, isAdmin, permissions });
}
modal.classList.add('hidden');
toast('User saved.', 'ok');
await refreshAdminUsers();
} catch (err) {
document.getElementById('user-error').textContent = err.message;
document.getElementById('user-error').classList.remove('hidden');
}
};
}
// ───────────────────────────────────────────────────────────────────────────
// SVG ICONS
// ───────────────────────────────────────────────────────────────────────────
const IMAGE_EXTS = new Set(['jpg','jpeg','png','gif','webp','svg','bmp','ico','avif']);
const VIDEO_EXTS = new Set(['mp4','webm','ogv','mov','avi','mkv']);
const AUDIO_EXTS = new Set(['mp3','ogg','wav','flac','aac','m4a']);
const DOC_EXTS = new Set(['pdf','doc','docx','xls','xlsx','ppt','pptx','odt','ods','odp']);
const 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']);
const ARCHIVE_EXTS= new Set(['zip','tar','gz','bz2','xz','rar','7z']);
function iconFolder(size = 52) {
return ``;
}
function iconFile(name, size = 52) {
const ext = extOf(name);
let color = '#7880a0';
let symbol = '';
if (IMAGE_EXTS.has(ext)) color = '#3fcf8e';
else if (VIDEO_EXTS.has(ext)) color = '#e05c6e';
else if (AUDIO_EXTS.has(ext)) color = '#c084fc';
else if (DOC_EXTS.has(ext)) color = '#f97316';
else if (CODE_EXTS.has(ext)) color = '#38bdf8';
else if (ARCHIVE_EXTS.has(ext))color = '#facc15';
return ``;
}
// ───────────────────────────────────────────────────────────────────────────
// EVENT WIRING
// ───────────────────────────────────────────────────────────────────────────
function wireEvents() {
// Auth form
document.getElementById('auth-form').addEventListener('submit', async (e) => {
e.preventDefault();
const username = document.getElementById('auth-username').value.trim();
const password = document.getElementById('auth-password').value;
const isSetup = e.target.dataset.mode === 'setup';
const errEl = document.getElementById('auth-error');
const btn = document.getElementById('auth-submit');
btn.disabled = true;
btn.textContent = 'Please wait…';
const err = await doLogin(username, password, isSetup);
if (err) {
errEl.textContent = err;
errEl.classList.remove('hidden');
btn.disabled = false;
btn.textContent = isSetup ? 'Create Account' : 'Sign In';
}
});
// Logout
document.getElementById('btn-logout').addEventListener('click', logout);
// Upload button
document.getElementById('btn-upload').addEventListener('click', () => {
if (!STATE.currentDir) { toast('Open a folder first.', 'err'); return; }
if (!canWrite()) { toast('No write access.', 'err'); return; }
document.getElementById('file-input').click();
});
document.getElementById('file-input').addEventListener('change', async (e) => {
if (e.target.files.length) await uploadFiles(e.target.files);
e.target.value = '';
});
// Sidebar close
document.getElementById('sidebar-close').addEventListener('click', closeSidebar);
// Click outside grid closes sidebar
document.getElementById('main-content').addEventListener('click', (e) => {
if (!e.target.closest('.file-item')) closeSidebar();
});
// Admin panel
document.getElementById('btn-admin').addEventListener('click', openAdminModal);
document.getElementById('admin-modal-close').addEventListener('click', () =>
document.getElementById('admin-modal').classList.add('hidden'));
// Add path
document.getElementById('admin-add-path').addEventListener('click', () => {
const val = document.getElementById('admin-new-path').value.trim();
if (!val) return;
const row = document.createElement('div');
row.className = 'path-row';
row.innerHTML = `${val}`;
row.querySelector('button').addEventListener('click', () => row.remove());
document.getElementById('admin-paths').appendChild(row);
document.getElementById('admin-new-path').value = '';
});
// Save paths
document.getElementById('admin-save-paths').addEventListener('click', async () => {
const rows = document.querySelectorAll('#admin-paths .path-row span');
const paths = [...rows].map(s => s.textContent.trim()).filter(Boolean);
try {
await api('PUT', '/admin/config', { paths });
toast('Paths saved.', 'ok');
await loadRoots();
} catch (err) { toast(err.message, 'err'); }
});
// Shutdown server
document.getElementById('admin-shutdown-btn').addEventListener('click', async () => {
if (!confirm('Shut down the server? You will lose access until it is restarted manually.')) return;
try {
await api('POST', '/admin/shutdown');
toast('Server is shutting down…', 'ok');
document.getElementById('admin-modal').classList.add('hidden');
} catch {
// Fetch may throw because the connection closes before a response arrives.
toast('Server is shutting down…', 'ok');
document.getElementById('admin-modal').classList.add('hidden');
}
});
// New user
document.getElementById('admin-new-user-btn').addEventListener('click', async () => {
const cfg = await api('GET', '/admin/config');
const paths = cfg ? (cfg.effectivePaths || []) : [];
openUserModal(null, paths);
});
// User modal close
document.getElementById('user-modal-close').addEventListener('click', () =>
document.getElementById('user-modal').classList.add('hidden'));
// Rename modal close
document.getElementById('rename-modal-close').addEventListener('click', () =>
document.getElementById('rename-modal').classList.add('hidden'));
// Close modals on backdrop click
document.querySelectorAll('.modal-overlay').forEach(overlay => {
overlay.addEventListener('click', e => {
if (e.target === overlay) overlay.classList.add('hidden');
});
});
}
// ───────────────────────────────────────────────────────────────────────────
// BOOT
// ───────────────────────────────────────────────────────────────────────────
(async function boot() {
wireEvents();
initDragDrop();
await initAuth();
})();