MoreMenu".
// Global Esc handler: close any currently-open kebab menu in the admin
// panel regardless of which _wireKebab instance owns it. Belt-and-braces
// backup for the per-instance handler below — registered once.
if (!document._admKebabEscWired) {
document._admKebabEscWired = true;
document.addEventListener('keydown', (e) => {
if (e.key !== 'Escape') return;
// Any visible kebab dropdown in the admin panel — match by id pattern
// so adding a new kebab elsewhere automatically benefits.
const menus = document.querySelectorAll(
'#adm-epLocalMoreMenu, #adm-epApiMoreMenu'
);
let closed = false;
menus.forEach((m) => {
if (m && m.style.display !== 'none') {
m.style.display = 'none';
// Sync the associated button's aria-expanded when we can find it.
const btn = document.getElementById(m.id.replace('Menu', 'Btn'));
if (btn) btn.setAttribute('aria-expanded', 'false');
closed = true;
}
});
if (closed) e.stopPropagation();
}, { capture: true });
}
const _wireKebab = (btnId, menuId, onItem) => {
const btn = el(btnId);
const menu = el(menuId);
if (!btn || !menu) return;
const isOpen = () => menu.style.display !== 'none';
const close = () => { menu.style.display = 'none'; btn.setAttribute('aria-expanded', 'false'); };
const open = () => { menu.style.display = 'flex'; btn.setAttribute('aria-expanded', 'true'); };
btn.addEventListener('click', (e) => {
e.stopPropagation();
if (isOpen()) close(); else open();
});
menu.addEventListener('click', (e) => {
const item = e.target.closest('.adm-more-item');
if (!item) return;
if (onItem) onItem(item, e);
close();
});
document.addEventListener('click', (e) => {
if (!isOpen()) return;
if (e.target.closest('#' + menuId + ', #' + btnId)) return;
close();
});
// Use capture phase so this fires before the settings-modal Esc handler
// (which is in bubble phase). stopPropagation prevents the modal from
// closing when the user only meant to dismiss this menu.
document.addEventListener('keydown', (e) => {
if (e.key === 'Escape' && isOpen()) {
e.stopPropagation();
close();
}
}, { capture: true });
};
// API card "..." menu: contains the Proxy/API connection-mode toggle.
// Sync the visible checkmarks with the hidden #adm-epKind select so
// downstream code (which reads kindSel.value) keeps working.
(function wireApiKindMenu() {
const kind = el('adm-epKind');
if (!kind) return;
const opts = document.querySelectorAll('#adm-epApiMoreMenu .adm-kind-opt');
const sync = () => {
opts.forEach((o) => {
const check = o.querySelector('.adm-kind-check');
if (check) check.style.visibility = (o.dataset.kind === kind.value) ? 'visible' : 'hidden';
});
};
sync();
kind.addEventListener('change', sync);
_wireKebab('adm-epApiMoreBtn', 'adm-epApiMoreMenu', (item) => {
const k = item.dataset.kind;
if (!k) return;
kind.value = k;
kind.dispatchEvent(new Event('change'));
});
})();
// Local card "..." kebab: holds Scan network / Ollama / API key reveal.
// Item buttons keep their own click handlers; the helper just handles
// open/close + outside-click + Esc.
_wireKebab('adm-epLocalMoreBtn', 'adm-epLocalMoreMenu');
// ── Added Models toolbar: Probe + Clear offline ────────────────────
// Both buttons act over the currently-rendered endpoint list. The
// online/offline marker is stamped on each row's [data-adm-ep-online]
// attribute by loadEndpoints(), so both buttons just iterate the DOM
// without re-fetching anything they don't already have.
const _refreshOfflineCount = () => {
const lbl = el('adm-epOfflineCount');
if (!lbl) return;
const n = document.querySelectorAll('[data-adm-ep-id] [data-adm-ep-online="0"]').length;
lbl.textContent = n > 0 ? `(${n})` : '';
// Hide the button entirely when there's nothing offline — no point
// showing an action that has nothing to act on.
const btn = el('adm-epClearOfflineBtn');
if (btn) btn.style.display = n === 0 ? 'none' : '';
};
// Wire after every loadEndpoints() run by patching the render hook —
// simplest path: MutationObserver on the two list containers.
const _obsRoots = ['adm-epList-local', 'adm-epList-api']
.map(id => el(id)).filter(Boolean);
if (_obsRoots.length) {
const mo = new MutationObserver(_refreshOfflineCount);
_obsRoots.forEach(r => mo.observe(r, { childList: true, subtree: true }));
_refreshOfflineCount();
}
const probeAllBtn = el('adm-epProbeAllBtn');
if (probeAllBtn) {
probeAllBtn.addEventListener('click', async () => {
probeAllBtn.disabled = true;
const origHTML = probeAllBtn.innerHTML;
let _wp = null;
try {
const sp = window.spinnerModule || (await import('./spinner.js')).default;
_wp = sp.createWhirlpool(11);
_wp.element.style.cssText = 'display:inline-flex;width:11px;height:11px;margin:0 4px 0 0;';
probeAllBtn.innerHTML = '';
probeAllBtn.appendChild(_wp.element);
probeAllBtn.appendChild(document.createTextNode('Probing'));
} catch (_) {
probeAllBtn.innerHTML = 'Probing…';
}
try {
// Hit the bulk local probe (same one the model picker uses).
await fetch('/api/model-endpoints/probe-local', { credentials: 'same-origin' }).catch(() => {});
// Then per-endpoint /probe for the rest so API/cloud endpoints
// refresh too. Parallel — capped to 6 at a time so we don't
// hammer the backend on a big list.
const ids = Array.from(document.querySelectorAll('[data-adm-ep-id]')).map(r => r.getAttribute('data-adm-ep-id')).filter(Boolean);
const lane = async (id) => {
try { await fetch(`/api/model-endpoints/${id}/probe`, { credentials: 'same-origin' }); } catch (_) {}
};
const queue = [...ids];
const workers = Array.from({length: Math.min(6, queue.length)}, () => (async () => {
while (queue.length) {
const id = queue.shift();
if (id) await lane(id);
}
})());
await Promise.all(workers);
await loadEndpoints();
if (uiModule && uiModule.showToast) uiModule.showToast('Endpoint status refreshed', 1800);
} finally {
if (_wp) { try { _wp.destroy(); } catch (_) {} }
probeAllBtn.innerHTML = origHTML;
probeAllBtn.disabled = false;
}
});
}
const clearOfflineBtn = el('adm-epClearOfflineBtn');
if (clearOfflineBtn) {
clearOfflineBtn.addEventListener('click', async () => {
const offlineBtns = Array.from(document.querySelectorAll('[data-adm-del-ep][data-adm-ep-online="0"]'));
const ids = offlineBtns.map(b => b.getAttribute('data-adm-del-ep')).filter(Boolean);
if (!ids.length) {
if (uiModule && uiModule.showToast) {
uiModule.showToast('No offline endpoints — nothing to clear', 1800);
}
return;
}
const confirmMsg = ids.length === 1
? 'Remove 1 offline endpoint?'
: `Remove ${ids.length} offline endpoints?`;
if (uiModule && uiModule.styledConfirm) {
const ok = await uiModule.styledConfirm(confirmMsg, { confirmText: 'Remove', danger: true });
if (!ok) return;
} else if (!confirm(confirmMsg)) {
return;
}
clearOfflineBtn.disabled = true;
// Optimistic UI: pull rows immediately, then fire the DELETEs.
offlineBtns.forEach(b => {
const row = b.closest('[data-adm-ep-id]');
if (row) row.remove();
});
await Promise.all(ids.map(id =>
fetch('/api/model-endpoints/' + id, { method: 'DELETE', credentials: 'same-origin' }).catch(() => {})
));
try { await loadEndpoints(); } catch (_) {}
_refreshOfflineCount();
if (uiModule && uiModule.showToast) uiModule.showToast(`Removed ${ids.length} offline endpoint${ids.length === 1 ? '' : 's'}`, 1800);
});
}
// Clear-on-focus for the API key inputs. The fields are type=password so the
// value is masked; users can't see what's there to edit it in place, so the
// expected gesture is "click in, type new key". Wiping on focus removes the
// select-all-and-delete dance.
const _wireClearOnFocus = (id) => {
const inp = el(id);
if (!inp) return;
inp.addEventListener('focus', () => {
if (inp.value) inp.value = '';
});
};
_wireClearOnFocus('adm-epLocalApiKey');
_wireClearOnFocus('adm-epApiKey');
// Drop the Ollama provider logo into the Ollama Quickstart button. Reuses
// the same SVG the provider picker uses, so brand parity stays free.
try {
const _ollamaLogoSlot = document.querySelector('#adm-epOllamaBtn .adm-ollama-logo');
if (_ollamaLogoSlot) {
const svg = providerLogo('ollama') || '';
if (svg) _ollamaLogoSlot.innerHTML = svg;
}
} catch (_) {}
// Local "Add" button — sibling form for self-hosted base URLs.
const localAddBtn = el('adm-epLocalAddBtn');
const localTestBtn = el('adm-epLocalTestBtn');
if (localTestBtn) {
localTestBtn.addEventListener('click', async () => {
const testOriginalHtml = localTestBtn.innerHTML || '>Test';
const msg = _endpointMsg('local');
msg.textContent = ''; msg.className = 'adm-ep-inline-msg';
const raw = (el('adm-epLocalUrl').value || '').trim();
if (!raw) { msg.textContent = 'Enter a base URL to test'; msg.className = 'admin-error'; return; }
const url = _normalizeBaseUrl(raw);
const keyEl = el('adm-epLocalApiKey');
const apiKey = keyEl ? keyEl.value.trim() : '';
localTestBtn.disabled = true;
localTestBtn.innerHTML = testOriginalHtml.replace(/>Test\s*$/, '>Testing...');
try {
const fd = new FormData();
fd.append('base_url', url);
if (apiKey) fd.append('api_key', apiKey);
const res = await fetch('/api/model-endpoints/test', { method: 'POST', body: fd, credentials: 'same-origin' });
const d = await res.json();
_renderEndpointTestResult(msg, res, d);
} catch (e) {
msg.textContent = 'Test failed: ' + (e && e.message ? e.message : 'request failed');
msg.className = 'admin-error';
}
localTestBtn.disabled = false;
localTestBtn.innerHTML = testOriginalHtml;
});
}
if (localAddBtn) {
localAddBtn.addEventListener('click', async () => {
const addOriginalHtml = localAddBtn.innerHTML || '>Add';
const msg = _endpointMsg('local');
msg.textContent = ''; msg.className = 'adm-ep-inline-msg';
const raw = (el('adm-epLocalUrl').value || '').trim();
if (!raw) { msg.textContent = 'Enter a base URL (e.g. http://localhost:8002/v1)'; msg.className = 'admin-error'; return; }
const url = _normalizeBaseUrl(raw);
const keyEl = el('adm-epLocalApiKey');
const apiKey = keyEl ? keyEl.value.trim() : '';
localAddBtn.disabled = true;
localAddBtn.innerHTML = addOriginalHtml.replace(/>Add\s*$/, '>Adding...');
try {
const fd = new FormData();
fd.append('base_url', url);
if (apiKey) fd.append('api_key', apiKey);
fd.append('endpoint_kind', 'local');
fd.append('model_refresh_mode', 'auto');
const lt = el('adm-epLocalType');
if (lt) fd.append('model_type', lt.value);
fd.append('skip_probe', 'false');
const res = await fetch('/api/model-endpoints', { method: 'POST', body: fd, credentials: 'same-origin' });
const d = await res.json();
if (res.ok) {
el('adm-epLocalUrl').value = '';
if (keyEl) keyEl.value = '';
if (lt) lt.value = 'llm';
if (d.id) _recentlyAddedEpId = String(d.id);
await loadEndpoints();
await _selectAddedModelInChat(d);
const count = (d.models || []).length;
const baseText = d.status === 'empty'
? 'Added — Ollama is running, no models pulled yet'
: d.online
? `Added — found ${count} model${count !== 1 ? 's' : ''}`
: 'Added (offline — will retry on next load)';
msg.innerHTML = `${baseText} Added Models →`;
msg.className = d.online ? 'admin-success' : 'admin-error';
} else { msg.textContent = d.detail || 'Failed'; msg.className = 'admin-error'; }
} catch (e) { msg.textContent = 'Request failed'; msg.className = 'admin-error'; }
localAddBtn.disabled = false;
localAddBtn.innerHTML = addOriginalHtml;
});
}
const ollamaBtn = el('adm-epOllamaBtn');
if (ollamaBtn) {
ollamaBtn.addEventListener('click', async () => {
const input = el('adm-epLocalUrl');
if (input) {
input.value = await _defaultOllamaUrl();
input.focus();
}
const msg = _endpointMsg('local');
if (msg) {
msg.innerHTML = 'Ollama ready to test.';
msg.className = '';
}
});
}
// Discover local models button
const discoverBtn = el('adm-epDiscoverBtn');
if (discoverBtn) {
discoverBtn.addEventListener('click', async () => {
const msg = _endpointMsg('local');
discoverBtn.disabled = true;
msg.className = 'adm-ep-inline-msg';
msg.innerHTML = '';
try {
const sp = window.spinnerModule || (await import('./spinner.js')).default;
const wp = sp.createWhirlpool(20);
wp.element.style.cssText = 'display:inline-block;vertical-align:middle;margin:0 8px 0 0;';
const wrap = document.createElement('div');
wrap.style.cssText = 'display:flex;align-items:center;padding:8px 0;';
wrap.appendChild(wp.element);
const txt = document.createElement('span');
txt.textContent = 'Scanning ports 8000-8020 and 11434 for model servers...';
txt.style.cssText = 'opacity:0.7;';
wrap.appendChild(txt);
msg.appendChild(wrap);
discoverBtn._wp = wp;
} catch(e) { msg.textContent = 'Scanning...'; }
try {
const res = await fetch('/api/discover');
const data = await res.json();
const items = data.items || [];
if (!items.length) {
msg.textContent = 'No model servers found. Make sure vLLM, llama.cpp, SGLang, or Ollama is running. Docker users may need Ollama bound to a trusted reachable interface.';
msg.className = 'admin-error';
} else {
// Auto-add each discovered endpoint. Server dedupes on base_url
// and returns `existing: true` for already-registered ones.
let added = 0;
let skipped = 0;
for (const item of items) {
const base = item.url.replace('/chat/completions', '').replace(/\/$/, '');
const fd = new FormData();
fd.append('base_url', base);
fd.append('endpoint_kind', 'local');
fd.append('model_refresh_mode', 'auto');
fd.append('skip_probe', 'false');
const r = await fetch('/api/model-endpoints', { method: 'POST', body: fd });
if (r.ok) {
try {
const dd = await r.json();
if (dd && dd.existing) { skipped++; }
else { added++; if (dd && dd.id) _recentlyAddedEpId = String(dd.id); }
} catch (_) { added++; }
}
}
const totalModels = items.reduce((n, i) => n + (i.models ? i.models.length : 0), 0);
const parts = [`Found ${items.length} server${items.length !== 1 ? 's' : ''} with ${totalModels} model${totalModels !== 1 ? 's' : ''}`];
if (added) parts.push(`added ${added} new`);
if (skipped) parts.push(`${skipped} already added`);
msg.innerHTML = parts.join(' — ');
msg.className = 'admin-success';
loadEndpoints();
}
} catch (e) {
msg.textContent = 'Scan failed: ' + e.message;
msg.className = 'admin-error';
}
if (discoverBtn._wp) { discoverBtn._wp.destroy(); discoverBtn._wp = null; }
discoverBtn.disabled = false;
discoverBtn.innerHTML = 'Scan for Servers';
});
}
document.querySelectorAll('.adm-quickstart-section').forEach((sec) => {
const head = sec.querySelector('.adm-quickstart-toggle');
if (!head) return;
const key = 'odysseus.addModels.' + sec.id + '.open';
let open = false;
try { open = localStorage.getItem(key) === '1'; } catch {}
const apply = () => {
sec.classList.toggle('collapsed', !open);
head.setAttribute('aria-expanded', open ? 'true' : 'false');
};
apply();
const toggle = () => {
open = !open;
try { localStorage.setItem(key, open ? '1' : '0'); } catch {}
apply();
};
head.addEventListener('click', toggle);
head.addEventListener('keydown', (e) => {
if (e.key === 'Enter' || e.key === ' ') { e.preventDefault(); toggle(); }
});
});
}
/* ═══════════════════════════════════════════
TOOLS TAB — MCP
═══════════════════════════════════════════ */
const _GOOGLE_OAUTH_HELP = `To get Google OAuth credentials:
1. Go to console.cloud.google.com
2. Click the project dropdown (top left) > New Project > name it > Create
3. APIs & Services > Library > enable the API you need (Gmail, Calendar, Drive, etc.)
4. APIs & Services > OAuth consent screen > configure (External, app name + email)
5. Under Audience, click Add Users > add your Google email as a test user
6. APIs & Services > Credentials > + Create Credentials > OAuth Client ID > Desktop App
7. Copy the Client ID and Client Secret into the fields above
8. After adding the server, click Authorize to sign in with Google
9. If accessing remotely: sign in, then copy the URL from the error page and paste it back`;
const MCP_PRESETS = [
{ name: "Gmail", command: "npx", args: ["-y", "@gongrzhe/server-gmail-autoauth-mcp"], env: { GOOGLE_CLIENT_ID: "", GOOGLE_CLIENT_SECRET: "" },
oauthFile: { dir: "gmail", filename: "gcp-oauth.keys.json" },
oauth: {
provider: "google",
keys_file: "gmail/gcp-oauth.keys.json",
token_file: "gmail/credentials.json",
scopes: ["https://www.googleapis.com/auth/gmail.modify", "https://www.googleapis.com/auth/gmail.settings.basic"],
},
help: `Setup:
1. Go to console.cloud.google.com > create or select a project
2. APIs & Services > Library > search "Gmail API" > Enable
3. APIs & Services > OAuth consent screen > set up (External is fine)
4. Under Audience, add your Gmail address as a test user
5. APIs & Services > Credentials > + Create Credentials > OAuth Client ID
6. Application type: Desktop App > Create
7. Copy the Client ID and Client Secret into the fields above
8. Click Add Server, then click the Authorize button
9. Sign in with Google, copy the URL from the error page, paste it back` },
{ name: "Email (IMAP/SMTP)", command: "npx", args: ["-y", "@codefuturist/email-mcp", "stdio"], env: { MCP_EMAIL_ADDRESS: "", MCP_EMAIL_PASSWORD: "", MCP_EMAIL_IMAP_HOST: "", MCP_EMAIL_SMTP_HOST: "" },
providerDropdown: {
label: "Provider",
targets: { MCP_EMAIL_IMAP_HOST: "imap", MCP_EMAIL_SMTP_HOST: "smtp" },
options: [
{ name: "Migadu", imap: "imap.migadu.com", smtp: "smtp.migadu.com" },
{ name: "Fastmail", imap: "imap.fastmail.com", smtp: "smtp.fastmail.com" },
{ name: "Proton Bridge", imap: "127.0.0.1", smtp: "127.0.0.1" },
{ name: "Outlook/Hotmail", imap: "outlook.office365.com", smtp: "smtp.office365.com" },
{ name: "Yahoo", imap: "imap.mail.yahoo.com", smtp: "smtp.mail.yahoo.com" },
{ name: "iCloud", imap: "imap.mail.me.com", smtp: "smtp.mail.me.com" },
{ name: "Zoho", imap: "imap.zoho.com", smtp: "smtp.zoho.com" },
{ name: "Custom", imap: "", smtp: "" },
],
},
help: "Works with any IMAP/SMTP email provider.\n1. Pick your provider from the dropdown (or choose Custom)\n2. Enter your email address and password (or app password)\n3. Click Add Server" },
{ name: "CalDAV (Radicale/Nextcloud)", command: "npx", args: ["-y", "caldav-mcp"], env: { CALDAV_BASE_URL: "http://localhost:5232", CALDAV_USERNAME: "", CALDAV_PASSWORD: "" },
help: "Works with any CalDAV server (Radicale, Nextcloud, etc.).\n1. Enter your CalDAV server URL (e.g. http://localhost:5232)\n2. Enter your username and password\n3. Click Add Server" },
{ name: "Google Calendar", command: "npx", args: ["-y", "@cocal/google-calendar-mcp"], env: { GOOGLE_OAUTH_CREDENTIALS: "" },
help: `Setup:
1. Go to console.cloud.google.com > create/select a project
2. APIs & Services > Library > enable Google Calendar API
3. APIs & Services > Credentials > + Create Credentials > OAuth Client ID
4. Application type: Desktop App > Create
5. Click "Download JSON" on the credential you just created
6. Set Google Oauth Credentials to the full path of the downloaded JSON file` },
{ name: "Google Drive", command: "npx", args: ["-y", "@modelcontextprotocol/server-gdrive"], env: {},
help: "Google Drive uses browser-based OAuth on first run. No env vars needed — just click Add and authorize when prompted." },
{ name: "GitHub", command: "npx", args: ["-y", "@modelcontextprotocol/server-github"], env: { GITHUB_PERSONAL_ACCESS_TOKEN: "" },
help: "1. Go to github.com > Settings > Developer Settings > Personal Access Tokens > Fine-grained tokens\n2. Generate a new token with the repo permissions you need\n3. Paste it as Github Personal Access Token" },
{ name: "Slack", command: "npx", args: ["-y", "@modelcontextprotocol/server-slack"], env: { SLACK_BOT_TOKEN: "", SLACK_TEAM_ID: "" },
help: "1. Go to api.slack.com/apps > Create New App > From Scratch\n2. Add Bot Token Scopes (channels:read, chat:write, etc.)\n3. Install to workspace, copy the Bot User OAuth Token (xoxb-...)\n4. Team ID is in your workspace URL or Slack admin settings" },
{ name: "Notion", command: "npx", args: ["-y", "@notionhq/notion-mcp-server"], env: { OPENAPI_MCP_HEADERS: "" },
help: "1. Go to notion.so/my-integrations\n2. Create a new integration\n3. Copy the Internal Integration Secret\n4. Share the Notion pages/databases you want accessible with the integration\n5. For Openapi Mcp Headers enter:\n {\"Authorization\": \"Bearer YOUR_SECRET\", \"Notion-Version\": \"2022-06-28\"}" },
{ name: "Linear", command: "npx", args: ["-y", "mcp-linear"], env: { LINEAR_API_KEY: "" },
help: "1. Go to linear.app > Settings > API\n2. Create a Personal API Key\n3. Paste it as Linear Api Key" },
{ name: "Brave Search", command: "npx", args: ["-y", "@modelcontextprotocol/server-brave-search"], env: { BRAVE_API_KEY: "" },
help: "1. Go to brave.com/search/api\n2. Sign up for a free plan (2000 queries/month)\n3. Copy your API key" },
{ name: "Browser (Playwright)", command: "npx", args: ["-y", "@playwright/mcp@latest", "--headless"], env: {},
help: "Browser automation via Playwright. The AI can navigate pages, click, fill forms, and read content.\nRuns headless by default. Remove --headless from Args to see the browser window.\nFirst run installs Chromium automatically." },
{ name: "Filesystem", command: "npx", args: ["-y", "@modelcontextprotocol/server-filesystem", "/home"], env: {},
help: "Edit the Args field to change which directory the server has access to." },
{ name: "Memory", command: "npx", args: ["-y", "@modelcontextprotocol/server-memory"], env: {} },
{ name: "Postgres", command: "npx", args: ["-y", "@modelcontextprotocol/server-postgres", "postgresql://user:pass@localhost/db"], env: {},
help: "Replace the connection string in the Args field with your actual Postgres connection URL." },
{ name: "Todoist", command: "npx", args: ["-y", "todoist-mcp-server"], env: { TODOIST_API_TOKEN: "" },
help: "1. Go to todoist.com > Settings > Integrations > Developer\n2. Copy your API token" },
];
// ── Built-in tools management ──
const TOOL_META = {
bash: { name: 'Shell', desc: 'Execute bash commands', cat: 'Code', ctx: '~200' },
python: { name: 'Python', desc: 'Run Python scripts', cat: 'Code', ctx: '~200' },
read_file: { name: 'Read File', desc: 'Read files from disk', cat: 'Code', ctx: '~150' },
write_file: { name: 'Write File', desc: 'Write/create files', cat: 'Code', ctx: '~150' },
web_search: { name: 'Web Search', desc: 'Search the web via SearXNG', cat: 'Search', ctx: '~300' },
search_chats: { name: 'Search Chats', desc: 'Search conversation history', cat: 'Search', ctx: '~150' },
create_document: { name: 'Create Document', desc: 'Create new documents', cat: 'Documents', ctx: '~200' },
update_document: { name: 'Update Document', desc: 'Modify existing documents', cat: 'Documents', ctx: '~200' },
edit_document: { name: 'Edit Document', desc: 'Find & replace in documents', cat: 'Documents', ctx: '~200' },
suggest_document: { name: 'Suggest Changes', desc: 'Propose document edits', cat: 'Documents', ctx: '~200' },
manage_documents: { name: 'Manage Documents', desc: 'List, delete, organize docs', cat: 'Documents', ctx: '~150' },
generate_image: { name: 'Generate Image', desc: 'Create images via AI', cat: 'Media', ctx: '~150' },
manage_memory: { name: 'Memory', desc: 'Save and recall memories', cat: 'Knowledge', ctx: '~200' },
manage_skills: { name: 'Skills', desc: 'Learn and use procedures', cat: 'Knowledge', ctx: '~200' },
manage_rag: { name: 'RAG / Docs', desc: 'Query indexed documents', cat: 'Knowledge', ctx: '~150' },
chat_with_model: { name: 'Chat with Model', desc: 'Talk to another AI model', cat: 'Multi-Agent', ctx: '~200' },
pipeline: { name: 'Pipeline', desc: 'Multi-step AI workflows', cat: 'Multi-Agent', ctx: '~200' },
ask_teacher: { name: 'Ask Teacher', desc: 'Query a more capable model', cat: 'Multi-Agent', ctx: '~150' },
send_to_session: { name: 'Send to Session', desc: 'Send message to another chat', cat: 'Sessions', ctx: '~100' },
create_session: { name: 'Create Session', desc: 'Start a new chat session', cat: 'Sessions', ctx: '~100' },
list_sessions: { name: 'List Sessions', desc: 'Browse existing sessions', cat: 'Sessions', ctx: '~100' },
manage_session: { name: 'Manage Session', desc: 'Rename, archive, configure', cat: 'Sessions', ctx: '~100' },
list_models: { name: 'List Models', desc: 'Show available models', cat: 'System', ctx: '~100' },
ui_control: { name: 'UI Control', desc: 'Change theme, layout, settings', cat: 'System', ctx: '~150' },
manage_tasks: { name: 'Tasks', desc: 'Schedule automated tasks', cat: 'System', ctx: '~150' },
api_call: { name: 'API Call', desc: 'Make HTTP requests', cat: 'System', ctx: '~200' },
manage_endpoints: { name: 'Endpoints', desc: 'Add/remove model endpoints', cat: 'System', ctx: '~100' },
manage_mcp: { name: 'MCP Servers', desc: 'Manage MCP connections', cat: 'System', ctx: '~100' },
manage_webhooks: { name: 'Webhooks', desc: 'Configure webhook events', cat: 'System', ctx: '~100' },
manage_tokens: { name: 'API Tokens', desc: 'Manage API access tokens', cat: 'System', ctx: '~100' },
manage_settings: { name: 'Settings', desc: 'Change app settings', cat: 'System', ctx: '~100' },
};
async function loadBuiltinTools() {
const list = el('adm-builtin-tools-list');
if (!list) return;
try {
const res = await fetch('/api/tools', { credentials: 'same-origin' });
const data = await res.json();
const tools = data.tools || [];
if (!tools.length) { list.innerHTML = 'No tools found
'; return; }
// Group by category
const groups = {};
for (const t of tools) {
const meta = TOOL_META[t.id] || { name: t.id, desc: '', cat: 'Other', ctx: '?' };
const cat = meta.cat;
if (!groups[cat]) groups[cat] = [];
groups[cat].push({ ...t, ...meta });
}
// Category order
const catOrder = ['Code', 'Search', 'Documents', 'Media', 'Knowledge', 'Multi-Agent', 'Sessions', 'System', 'Other'];
let html = '';
for (const cat of catOrder) {
const items = groups[cat];
if (!items) continue;
const enabledCount = items.filter(i => i.enabled).length;
const totalCount = items.length;
const catId = 'tool-cat-' + cat.replace(/[^a-zA-Z]/g, '');
const allEnabled = enabledCount === totalCount;
html += `';
}
list.innerHTML = html;
// Prevent toggle clicks from expanding/collapsing
list.querySelectorAll('.admin-tool-cat-right').forEach(span => {
span.addEventListener('click', e => e.stopPropagation());
});
// Wire category expand/collapse
list.querySelectorAll('[data-tool-cat]').forEach(header => {
header.addEventListener('click', () => {
const body = el(header.dataset.toolCat);
if (!body) return;
body.classList.toggle('hidden');
const chevron = header.querySelector('.admin-tool-cat-chevron');
const isOpen = !body.classList.contains('hidden');
if (chevron) {
chevron.style.transform = isOpen ? 'rotate(180deg)' : '';
chevron.style.opacity = isOpen ? '0.7' : '0.3';
}
});
});
// Helper: save disabled tools + update counters
async function _saveToolState() {
const allChecks = list.querySelectorAll('input[data-tool-id]');
const disabled = [];
allChecks.forEach(c => { if (!c.checked) disabled.push(c.dataset.toolId); });
await fetch('/api/tools', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ disabled }),
credentials: 'same-origin',
});
}
function _updateCatCounter(catEl) {
if (!catEl) return;
const catChecks = catEl.querySelectorAll('input[data-tool-id]');
const catEnabled = Array.from(catChecks).filter(c => c.checked).length;
const counter = catEl.querySelector('.admin-tool-cat-count');
if (counter) counter.textContent = catEnabled + '/' + catChecks.length;
const catToggle = catEl.querySelector('input[data-tool-cat-toggle]');
if (catToggle) catToggle.checked = (catEnabled === catChecks.length);
}
// Wire individual tool toggles
list.querySelectorAll('input[data-tool-id]').forEach(chk => {
chk.addEventListener('change', async () => {
await _saveToolState();
_updateCatCounter(chk.closest('.admin-tool-category'));
});
});
// Wire category-level toggle (enable/disable all in category)
list.querySelectorAll('input[data-tool-cat-toggle]').forEach(chk => {
chk.addEventListener('change', async () => {
const catEl = chk.closest('.admin-tool-category');
if (!catEl) return;
const checked = chk.checked;
catEl.querySelectorAll('input[data-tool-id]').forEach(c => { c.checked = checked; });
await _saveToolState();
_updateCatCounter(catEl);
});
});
} catch (e) {
console.error('Failed to load tools:', e);
list.innerHTML = 'Failed to load tools
';
}
}
async function loadMcpServers() {
const list = el('adm-mcpList');
if (!list) return; // MCP section not visible / not yet rendered
try {
const res = await fetch('/api/mcp/servers', { credentials: 'same-origin' });
const servers = await res.json();
if (!servers.length) { list.innerHTML = 'No MCP servers configured
'; return; }
list.innerHTML = servers.map(s => {
const statusColor = s.needs_oauth ? '#e5a33a' : s.status === 'connected' ? 'var(--fg)' : s.status === 'error' ? 'var(--red)' : 'color-mix(in srgb, var(--fg) 50%, transparent)';
const toolInfo = s.status === 'connected' ? `${s.enabled_tool_count}/${s.tool_count} tools enabled` : '';
const statusText = s.needs_oauth ? 'Needs authorization' : s.status === 'connected' ? `Connected (${toolInfo})` : s.status === 'error' ? `Error: ${s.error || 'unknown'}` : 'Disconnected';
const hasTools = s.status === 'connected' && s.tool_count > 0;
return `
${esc(s.name)}
${statusText}
${hasTools ? `Click to manage tools` : ''}
${s.needs_oauth ? `
Authorize` : ''}
${hasTools ? '
' : ''}
${hasTools ? `
` : ''}
`;
}).join('');
list.querySelectorAll('[data-adm-mcp-reconnect]').forEach(btn => {
btn.addEventListener('click', async () => {
const msg = el('adm-mcpMsg'); msg.textContent = 'Reconnecting...'; msg.className = '';
try {
const res = await fetch(`/api/mcp/servers/${btn.dataset.admMcpReconnect}/reconnect`, { method: 'POST', credentials: 'same-origin' });
const data = await res.json();
msg.textContent = data.connected ? `Reconnected (${data.tool_count} tools)` : `Failed: ${data.error || 'unknown'}`;
msg.className = data.connected ? 'admin-success' : 'admin-error';
loadMcpServers();
} catch (e) { msg.textContent = 'Failed: ' + e.message; msg.className = 'admin-error'; }
});
});
list.querySelectorAll('[data-adm-mcp-toggle]').forEach(btn => {
btn.addEventListener('click', async () => {
const fd = new FormData(); fd.append('is_enabled', btn.dataset.admMcpEnable);
await fetch(`/api/mcp/servers/${btn.dataset.admMcpToggle}`, { method: 'PATCH', body: fd, credentials: 'same-origin' });
loadMcpServers();
});
});
list.querySelectorAll('[data-adm-mcp-delete]').forEach(btn => {
btn.addEventListener('click', async () => {
if (!await uiModule.styledConfirm('Delete this MCP server?', { confirmText: 'Delete', danger: true })) return;
await fetch(`/api/mcp/servers/${btn.dataset.admMcpDelete}`, { method: 'DELETE', credentials: 'same-origin' });
loadMcpServers();
});
});
// Tools expand/collapse (click anywhere on card)
list.querySelectorAll('[data-adm-mcp-id]').forEach(row => {
const header = row.querySelector('[data-adm-mcp-header]');
if (!header) return;
let _toolsLoaded = false;
row.style.cursor = 'pointer';
row.addEventListener('click', async (e) => {
if (e.target.closest('.admin-btn-sm, .admin-btn-delete, a, .mcp-tools-list, .mcp-tools-header')) return;
const sid = header.dataset.admMcpHeader;
const panel = row.querySelector(`[data-adm-mcp-tools-panel="${sid}"]`);
if (!panel) return;
panel.classList.toggle('hidden');
const chevron = row.querySelector('.admin-user-chevron');
const isOpen = !panel.classList.contains('hidden');
if (chevron) {
chevron.style.transform = isOpen ? 'rotate(180deg)' : '';
chevron.style.opacity = isOpen ? '0.7' : '0.3';
}
if (!_toolsLoaded && isOpen) {
_toolsLoaded = true;
panel.innerHTML = 'Loading tools...';
try {
const res = await fetch(`/api/mcp/servers/${sid}/tools`, { credentials: 'same-origin' });
const tools = await res.json();
if (!tools.length) { panel.innerHTML = 'No tools'; return; }
const disabled = new Set(tools.filter(t => t.is_disabled).map(t => t.name));
panel.innerHTML = `` + tools.map(t =>
``
).join('') + '
';
panel.querySelector(`[data-mcp-select-all="${sid}"]`)?.addEventListener('click', (e) => {
e.preventDefault();
panel.querySelectorAll('input[type=checkbox]').forEach(cb => cb.checked = true);
_saveMcpToolState(sid, panel);
});
panel.querySelector(`[data-mcp-select-none="${sid}"]`)?.addEventListener('click', (e) => {
e.preventDefault();
panel.querySelectorAll('input[type=checkbox]').forEach(cb => cb.checked = false);
_saveMcpToolState(sid, panel);
});
panel.querySelectorAll('input[type=checkbox]').forEach(cb => {
cb.addEventListener('change', () => _saveMcpToolState(sid, panel));
});
} catch (e) { panel.innerHTML = 'Failed to load tools'; }
}
});
});
} catch (e) { if (list) list.innerHTML = 'Failed to load MCP servers
'; }
}
async function _saveMcpToolState(serverId, panel) {
const disabled = [];
panel.querySelectorAll('input[type=checkbox]').forEach(cb => {
if (!cb.checked) disabled.push(cb.dataset.mcpToolName);
});
const total = panel.querySelectorAll('input[type=checkbox]').length;
try {
await fetch(`/api/mcp/servers/${serverId}/tools`, {
method: 'PATCH',
headers: { 'Content-Type': 'application/json' },
credentials: 'same-origin',
body: JSON.stringify({ disabled }),
});
// Update the count label in the panel
const countLabel = panel.querySelector('.mcp-tools-count');
if (countLabel) countLabel.textContent = `${total - disabled.length}/${total} enabled`;
// Update badge in the server row
const row = panel.closest('[data-adm-mcp-id]');
if (row) {
const badge = row.querySelector('.admin-badge');
if (badge) badge.textContent = `Connected (${total - disabled.length}/${total} tools enabled)`;
}
} catch (e) { /* silent */ }
}
function initMcpForm() {
const cmdEl = el('adm-mcpCommand');
if (!cmdEl) return; // MCP form not present in this build — nothing to wire
const transportSel = el('adm-mcpTransport');
const sseRow = el('adm-mcpSseRow');
const envRow = el('adm-mcpEnvRow');
const envFieldsWrap = el('adm-mcpEnvFields');
const helpBox = el('adm-mcpHelp');
const cmdRow = cmdEl.parentElement;
let _activeHelp = null;
let _envKeys = []; // track which env keys have dedicated fields
let _activeOauthFile = null; // preset oauthFile config (for Google servers)
let _activeOauth = null; // preset OAuth flow config (provider, scopes, etc.)
function _clearEnvFields() {
envFieldsWrap.innerHTML = '';
_envKeys = [];
envRow.style.display = 'none';
el('adm-mcpEnv').value = '';
_activeOauth = null;
}
function _buildEnvFields(envObj, help, preset) {
_clearEnvFields();
const keys = Object.keys(envObj);
if (!keys.length) return;
_envKeys = keys;
// Provider dropdown (e.g. for Email IMAP/SMTP)
if (preset?.providerDropdown) {
const pd = preset.providerDropdown;
const row = document.createElement('div');
row.className = 'admin-model-form-row';
row.style.cssText = 'gap:6px;align-items:center;';
const label = document.createElement('span');
label.style.cssText = 'font-size:11px;opacity:0.55;min-width:0;white-space:nowrap;';
label.textContent = pd.label || 'Provider';
const select = document.createElement('select');
select.style.cssText = 'flex:1;padding:6px 8px;border-radius:6px;border:1px solid var(--border);background:var(--bg-secondary);color:var(--text-primary);font-size:12px;';
pd.options.forEach((opt, i) => {
const o = document.createElement('option');
o.value = i;
o.textContent = opt.name;
select.appendChild(o);
});
select.addEventListener('change', () => {
const opt = pd.options[parseInt(select.value)];
for (const [envKey, field] of Object.entries(pd.targets)) {
const inp = envFieldsWrap.querySelector(`.mcp-env-input[data-env-key="${envKey}"]`);
if (inp) inp.value = opt[field] || '';
}
});
row.appendChild(label);
row.appendChild(select);
envFieldsWrap.appendChild(row);
// Auto-fill with first provider after inputs are created
setTimeout(() => {
const first = pd.options[0];
for (const [envKey, field] of Object.entries(pd.targets)) {
const inp = envFieldsWrap.querySelector(`.mcp-env-input[data-env-key="${envKey}"]`);
if (inp && !inp.value) inp.value = first[field] || '';
}
}, 0);
}
for (const key of keys) {
const row = document.createElement('div');
row.className = 'admin-model-form-row';
row.style.cssText = 'gap:6px;align-items:center;';
const label = document.createElement('span');
label.style.cssText = 'font-size:11px;opacity:0.55;min-width:0;white-space:nowrap;';
label.textContent = key.replace(/_/g, ' ').replace(/\b\w/g, c => c.toUpperCase());
const input = document.createElement('input');
input.type = key.toLowerCase().includes('secret') || key.toLowerCase().includes('token') || key.toLowerCase().includes('key') || key.toLowerCase().includes('password') ? 'password' : 'text';
input.placeholder = key;
input.dataset.envKey = key;
input.className = 'mcp-env-input';
input.style.cssText = 'flex:1;';
if (envObj[key]) input.value = envObj[key];
row.appendChild(label);
row.appendChild(input);
envFieldsWrap.appendChild(row);
}
// Help toggle link
if (help) {
_activeHelp = help;
const helpLink = document.createElement('a');
helpLink.textContent = 'How do I get these?';
helpLink.href = '#';
helpLink.style.cssText = 'font-size:10.5px;opacity:0.5;margin-top:2px;display:inline-block;';
helpLink.addEventListener('click', (e) => {
e.preventDefault();
helpBox.style.display = helpBox.style.display === 'none' ? '' : 'none';
});
envFieldsWrap.appendChild(helpLink);
helpBox.textContent = help;
helpBox.style.display = 'none';
} else {
_activeHelp = null;
helpBox.style.display = 'none';
}
}
// Collect env from either dedicated fields or raw JSON fallback
function _collectEnv() {
if (_envKeys.length) {
const obj = {};
envFieldsWrap.querySelectorAll('.mcp-env-input').forEach(inp => {
if (inp.value.trim()) obj[inp.dataset.envKey] = inp.value.trim();
});
return JSON.stringify(obj);
}
return el('adm-mcpEnv').value.trim() || '{}';
}
transportSel.addEventListener('change', () => {
const isSse = transportSel.value === 'sse';
sseRow.style.display = isSse ? '' : 'none';
cmdRow.style.display = isSse ? 'none' : '';
if (isSse) { _clearEnvFields(); helpBox.style.display = 'none'; }
});
// Preset catalog
const presetSel = el('adm-mcpPreset');
if (presetSel) {
MCP_PRESETS.forEach((p, i) => {
const opt = document.createElement('option');
opt.value = i;
opt.textContent = p.name + (Object.keys(p.env).length ? ' (requires keys)' : '');
presetSel.appendChild(opt);
});
presetSel.addEventListener('change', () => {
if (presetSel.value === '') return;
const p = MCP_PRESETS[parseInt(presetSel.value)];
el('adm-mcpName').value = p.name.toLowerCase().replace(/\s+/g, '-');
transportSel.value = 'stdio';
el('adm-mcpCommand').value = p.command;
el('adm-mcpArgs').value = JSON.stringify(p.args);
sseRow.style.display = 'none';
cmdRow.style.display = '';
_buildEnvFields(p.env, p.help || null, p);
_activeOauthFile = p.oauthFile || null;
_activeOauth = p.oauth || null;
presetSel.value = '';
// Focus first env field if keys are needed
const firstInput = envFieldsWrap.querySelector('.mcp-env-input');
if (firstInput) firstInput.focus();
else el('adm-mcpAddBtn').focus();
});
}
el('adm-mcpAddBtn').addEventListener('click', async () => {
const name = el('adm-mcpName').value.trim();
const transport = transportSel.value;
const command = el('adm-mcpCommand').value.trim();
const args = el('adm-mcpArgs').value.trim() || '[]';
const env = _collectEnv();
const url = el('adm-mcpUrl').value.trim();
const msg = el('adm-mcpMsg');
if (!name) { msg.textContent = 'Name is required'; msg.className = 'admin-error'; return; }
if (transport === 'stdio' && !command) { msg.textContent = 'Command is required for stdio'; msg.className = 'admin-error'; return; }
if (transport === 'sse' && !url) { msg.textContent = 'URL is required for SSE'; msg.className = 'admin-error'; return; }
try { JSON.parse(env); } catch { msg.textContent = 'Env must be valid JSON'; msg.className = 'admin-error'; return; }
const fd = new FormData();
fd.append('name', name); fd.append('transport', transport); fd.append('command', command); fd.append('args', args); fd.append('env', env); fd.append('url', url);
// If preset has oauthFile config, send credentials for file generation
if (_activeOauthFile) {
const envObj = JSON.parse(env);
fd.append('oauth_file', JSON.stringify({
dir: _activeOauthFile.dir,
filename: _activeOauthFile.filename,
client_id: envObj.GOOGLE_CLIENT_ID || '',
client_secret: envObj.GOOGLE_CLIENT_SECRET || '',
}));
}
// If preset has OAuth flow config, send it so the server can handle authorization
if (_activeOauth) {
fd.append('oauth_config', JSON.stringify(_activeOauth));
}
msg.textContent = 'Adding...'; msg.className = '';
try {
const res = await fetch('/api/mcp/servers', { method: 'POST', body: fd, credentials: 'same-origin' });
const data = await res.json();
if (data.needs_oauth) {
msg.innerHTML = `Added ${esc(name)} — Authorize with Google to connect`;
msg.className = 'admin-success';
} else if (data.connected) {
msg.textContent = `Added ${name} (${data.tool_count} tools discovered)`; msg.className = 'admin-success';
} else { msg.textContent = `Added but connection failed: ${data.error || 'unknown'}`; msg.className = 'admin-error'; }
el('adm-mcpName').value = ''; el('adm-mcpCommand').value = ''; el('adm-mcpArgs').value = ''; el('adm-mcpUrl').value = '';
_clearEnvFields(); helpBox.style.display = 'none'; _activeHelp = null; _activeOauthFile = null; _activeOauth = null;
loadMcpServers();
} catch (e) { msg.textContent = 'Failed: ' + e.message; msg.className = 'admin-error'; }
});
}
/* ── Embedding model ──
No settings UI: the embedding model (RAG, semantic memory, tool selection)
is fixed infrastructure that ships with the app, and swapping it would
invalidate every existing vector. Configure via the FASTEMBED_MODEL /
EMBEDDING_URL env vars if you really need to override it. */
/* ── RAG ── */
async function loadRag() {
try {
const res = await fetch('/api/personal');
const data = await res.json();
const dirList = el('adm-ragDirList');
const dirs = data.directories || [];
if (dirs.length === 0) { dirList.innerHTML = 'No directories indexed
'; }
else {
dirList.innerHTML = dirs.map(d => `${esc(d)}
`).join('');
dirList.querySelectorAll('[data-adm-rag-dir]').forEach(btn => {
btn.addEventListener('click', async () => {
if (!await uiModule.styledConfirm(`Remove directory "${btn.dataset.admRagDir}" from RAG?`, { confirmText: 'Remove', danger: true })) return;
btn.disabled = true; btn.textContent = '...';
try {
const res = await fetch('/api/personal/remove_directory?directory=' + encodeURIComponent(btn.dataset.admRagDir), { method: 'DELETE' });
if (res.ok) { ragMsg('Directory removed'); loadRag(); }
else { const e = await res.json(); ragMsg(e.detail || 'Failed', true); }
} catch (e) { ragMsg('Error: ' + e.message, true); }
});
});
}
const fileList = el('adm-ragFileList');
const files = data.files || [];
if (files.length === 0) { fileList.innerHTML = 'No files indexed
'; }
else {
fileList.innerHTML = files.map(f => {
const size = f.size ? (f.size > 1024 ? (f.size / 1024).toFixed(1) + ' KB' : f.size + ' B') : '';
return `${esc(f.name)}${size}
`;
}).join('');
fileList.querySelectorAll('[data-adm-rag-file]').forEach(btn => {
btn.addEventListener('click', async () => {
if (!await uiModule.styledConfirm(`Delete "${btn.dataset.admRagFile}" from RAG?`, { confirmText: 'Delete', danger: true })) return;
btn.disabled = true; btn.textContent = '...';
try {
const res = await fetch('/api/personal/file?filepath=' + encodeURIComponent(btn.dataset.admRagFile), { method: 'DELETE' });
if (res.ok) { ragMsg('File removed'); loadRag(); }
else { const e = await res.json(); ragMsg(e.detail || 'Failed', true); }
} catch (e) { ragMsg('Error: ' + e.message, true); }
});
});
}
} catch (e) {
el('adm-ragDirList').innerHTML = 'Failed to load
';
el('adm-ragFileList').innerHTML = '';
}
}
let _ragMsgTimer = null;
function ragMsg(text, isError, persist) {
const s = el('adm-ragStatus');
s.textContent = text; s.style.color = isError ? 'var(--red)' : 'var(--fg)';
if (_ragMsgTimer) { clearTimeout(_ragMsgTimer); _ragMsgTimer = null; }
if (text && !persist) _ragMsgTimer = setTimeout(() => { s.textContent = ''; }, 5000);
}
async function ragUpload(files) {
if (!files || files.length === 0) return;
ragMsg('Uploading ' + files.length + ' file(s)...', false, true);
const fd = new FormData();
for (const f of files) fd.append('files', f);
try {
const res = await fetch('/api/personal/upload', { method: 'POST', body: fd });
const data = await res.json();
if (data.success) { ragMsg(`Uploaded ${data.uploaded.length} file(s), ${data.indexed_count} chunks indexed`); loadRag(); }
else ragMsg(data.detail || 'Upload failed', true);
} catch (e) { ragMsg('Upload error: ' + e.message, true); }
}
function initRag() {
const dropZone = el('adm-ragDropZone');
const fileInput = el('adm-ragFileInput');
dropZone.addEventListener('click', () => fileInput.click());
fileInput.addEventListener('change', () => ragUpload(fileInput.files));
dropZone.addEventListener('dragover', e => { e.preventDefault(); dropZone.classList.add('dragover'); });
dropZone.addEventListener('dragleave', () => dropZone.classList.remove('dragover'));
dropZone.addEventListener('drop', e => { e.preventDefault(); dropZone.classList.remove('dragover'); ragUpload(e.dataTransfer.files); });
el('adm-ragAddDirBtn').addEventListener('click', async () => {
const dir = el('adm-ragDirInput').value.trim();
if (!dir) return;
const btn = el('adm-ragAddDirBtn');
btn.disabled = true; btn.textContent = 'Indexing...';
try {
const res = await fetch('/api/personal/add_directory', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ directory: dir }) });
const data = await res.json();
if (data.success) { ragMsg(`Indexed ${data.indexed_count} chunks from directory`); el('adm-ragDirInput').value = ''; loadRag(); }
else ragMsg(data.detail || data.message || 'Failed', true);
} catch (e) { ragMsg('Error: ' + e.message, true); }
btn.disabled = false; btn.textContent = 'Add Directory';
});
el('adm-ragReloadBtn').addEventListener('click', async () => {
const btn = el('adm-ragReloadBtn');
btn.disabled = true; btn.textContent = 'Reloading...';
try {
const res = await fetch('/api/personal/reload', { method: 'POST' });
const data = await res.json();
ragMsg(`Index reloaded: ${data.count} documents`);
loadRag();
} catch (e) { ragMsg('Reload failed: ' + e.message, true); }
btn.disabled = false; btn.textContent = 'Reload Index';
});
}
/* ═══════════════════════════════════════════
SYSTEM TAB — Tokens
═══════════════════════════════════════════ */
// Catalog mirrors the one in settings.js integration form. Keep keys in
// sync with the backend scope allowlist.
const _TOKEN_SCOPES = [
{ key: 'todos:read', label: 'Todos read', detail: 'Read notes and checklists' },
{ key: 'todos:write', label: 'Todos write', detail: 'Create, update, delete, and toggle todo items' },
{ key: 'documents:read', label: 'Documents read', detail: 'Read documents when a document API is enabled' },
{ key: 'documents:write', label: 'Documents write', detail: 'Create and update draft documents' },
{ key: 'email:read', label: 'Email read', detail: 'Read email when an email API is enabled' },
{ key: 'email:draft', label: 'Email draft', detail: 'Create email reply drafts without sending' },
{ key: 'email:send', label: 'Email send', detail: 'Send email directly' },
{ key: 'calendar:read', label: 'Calendar read', detail: 'Read calendar events when enabled' },
{ key: 'calendar:write', label: 'Calendar write', detail: 'Create and update calendar events' },
{ key: 'memory:read', label: 'Memory read', detail: 'Read memory when enabled' },
{ key: 'memory:write', label: 'Memory write', detail: 'Write memory when enabled' },
{ key: 'cookbook:read', label: 'Cookbook read', detail: 'List cookbook tasks + tail their tmux output' },
{ key: 'cookbook:launch', label: 'Cookbook launch', detail: 'Launch and stop cookbook serve tasks' },
];
function _renderTokenScopeRows(t) {
const have = new Set(t.scopes || []);
return _TOKEN_SCOPES.map(s => {
const action = (s.key.split(':')[1] || '').toLowerCase();
const pill = action === 'read'
? 'background:rgba(150,150,150,0.18);color:var(--fg-muted,#888);'
: 'background:color-mix(in srgb, var(--accent, var(--red)) 18%, transparent);color:var(--accent, var(--red));';
const tool = s.label.replace(/\s+(read|write|draft|send|launch)$/i, '');
return `
`;
}).join('');
}
async function loadTokens() {
const list = el('adm-tokenList');
if (!list) return;
try {
const res = await fetch('/api/tokens', { credentials: 'same-origin' });
const tokens = await res.json();
if (!tokens.length) { list.innerHTML = 'No API tokens
'; return; }
list.innerHTML = tokens.map(t => `
${_renderTokenScopeRows(t)}
`).join('');
// Revoke
list.querySelectorAll('[data-adm-del-token]').forEach(btn => {
btn.addEventListener('click', async () => {
if (!await uiModule.styledConfirm('Revoke this API token? External integrations using it will stop working.', { confirmText: 'Revoke', danger: true })) return;
await fetch(`/api/tokens/${btn.dataset.admDelToken}`, { method: 'DELETE', credentials: 'same-origin' });
loadTokens();
// Codex / Claude integration cards on the Integrations panel are
// backed by these tokens — let them re-render so the deleted token
// disappears there too.
try { window.dispatchEvent(new CustomEvent('odysseus-integrations-changed')); } catch (_) {}
});
});
// Toggle permissions panel
list.querySelectorAll('[data-adm-tok-toggle]').forEach(btn => {
btn.addEventListener('click', () => {
const panel = list.querySelector(`[data-adm-tok-perm="${btn.dataset.admTokToggle}"]`);
if (!panel) return;
panel.style.display = panel.style.display === 'none' ? '' : 'none';
});
});
// Rename
list.querySelectorAll('.adm-tok-rename').forEach(input => {
const original = input.value;
const commit = async () => {
const name = (input.value || '').trim();
if (!name || name === original) return;
try {
const r = await fetch(`/api/tokens/${input.dataset.tokenId}`, {
method: 'PATCH', credentials: 'same-origin',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ name }),
});
if (!r.ok) throw new Error('Save failed');
loadTokens();
} catch (_) { input.value = original; }
};
input.addEventListener('blur', commit);
input.addEventListener('keydown', e => { if (e.key === 'Enter') { e.preventDefault(); input.blur(); } });
});
// Scope toggle change → PATCH the whole scopes array for this token.
list.querySelectorAll('.adm-tok-scope').forEach(cb => {
cb.addEventListener('change', async () => {
const tokenId = cb.dataset.tokenId;
const panel = list.querySelector(`[data-adm-tok-perm="${tokenId}"]`);
const msg = list.querySelector(`.adm-tok-scope-msg[data-token-id="${tokenId}"]`);
const scopes = Array.from(panel.querySelectorAll('.adm-tok-scope:checked')).map(input => input.dataset.scope);
try {
const r = await fetch(`/api/tokens/${tokenId}`, {
method: 'PATCH', credentials: 'same-origin',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ scopes }),
});
const d = await r.json().catch(() => ({}));
if (!r.ok) throw new Error(d.detail || 'Failed');
if (msg) { msg.textContent = 'Saved'; msg.style.color = 'var(--green, #50fa7b)'; setTimeout(() => { msg.textContent = ''; }, 1200); }
} catch (err) {
cb.checked = !cb.checked;
if (msg) { msg.textContent = (err && err.message) || 'Failed'; msg.style.color = 'var(--red)'; }
}
});
});
} catch (e) { list.innerHTML = 'Failed to load tokens
'; }
}
function initTokenForm() {
const addBtn = el('adm-tokenAddBtn');
if (!addBtn || addBtn.dataset.bound) return;
addBtn.dataset.bound = '1';
addBtn.addEventListener('click', async () => {
const msg = el('adm-tokenMsg');
const reveal = el('adm-tokenReveal');
msg.textContent = ''; msg.className = ''; reveal.style.display = 'none';
const name = el('adm-tokenName').value.trim();
if (!name) { msg.textContent = 'Token name is required'; msg.className = 'admin-error'; return; }
const fd = new FormData(); fd.append('name', name);
const scopes = (el('adm-tokenScopes')?.value || '').trim();
if (scopes) fd.append('scopes', scopes);
try {
const res = await fetch('/api/tokens', { method: 'POST', body: fd, credentials: 'same-origin' });
const data = await res.json();
if (res.ok) {
el('adm-tokenValue').textContent = data.token;
reveal.style.display = '';
el('adm-tokenName').value = '';
if (el('adm-tokenScopes')) el('adm-tokenScopes').value = '';
loadTokens();
}
else { msg.textContent = data.detail || 'Failed'; msg.className = 'admin-error'; }
} catch (e) { msg.textContent = 'Request failed'; msg.className = 'admin-error'; }
});
const TOKEN_COPY_ICON = '';
const TOKEN_CHECK_ICON = '';
el('adm-tokenCopyBtn').addEventListener('click', () => {
const val = el('adm-tokenValue').textContent;
const btn = el('adm-tokenCopyBtn');
navigator.clipboard.writeText(val).then(() => {
btn.innerHTML = TOKEN_CHECK_ICON;
btn.style.color = 'var(--accent, var(--red))';
btn.style.opacity = '1';
setTimeout(() => {
btn.innerHTML = TOKEN_COPY_ICON;
btn.style.color = '';
btn.style.opacity = '0.7';
}, 1600);
});
});
}
/* ── Webhooks ── */
async function loadWebhooks() {
const list = el('adm-whList');
try {
const res = await fetch('/api/webhooks', { credentials: 'same-origin' });
const hooks = await res.json();
if (!hooks.length) { list.innerHTML = 'No webhooks configured
'; return; }
list.innerHTML = hooks.map(w => {
const events = (w.events || []).map(e => `${esc(e)}`).join(' ');
const statusBadge = w.last_status_code
? `${w.last_status_code}`
: '';
const lastTriggered = w.last_triggered_at ? new Date(w.last_triggered_at).toLocaleString() : 'Never';
const errorText = w.last_error ? `Error: ${esc(w.last_error.substring(0, 80))}
` : '';
return `
${esc(w.name)} ${w.is_active ? '' : 'disabled'} ${w.has_secret ? 'signed' : ''}
${esc(w.url)}
${events}
Last: ${lastTriggered} ${statusBadge}
${errorText}
`;
}).join('');
list.querySelectorAll('[data-adm-wh-test]').forEach(btn => {
btn.addEventListener('click', async () => {
const msg = el('adm-whMsg'); msg.textContent = 'Sending test...'; msg.className = '';
try {
const res = await fetch(`/api/webhooks/${btn.dataset.admWhTest}/test`, { method: 'POST', credentials: 'same-origin' });
msg.textContent = res.ok ? 'Test sent!' : 'Test failed'; msg.className = res.ok ? 'admin-success' : 'admin-error';
setTimeout(() => loadWebhooks(), 1000);
} catch (e) { msg.textContent = 'Failed: ' + e.message; msg.className = 'admin-error'; }
});
});
list.querySelectorAll('[data-adm-wh-toggle]').forEach(btn => {
btn.addEventListener('click', async () => { await fetch(`/api/webhooks/${btn.dataset.admWhToggle}`, { method: 'PATCH', credentials: 'same-origin' }); loadWebhooks(); });
});
list.querySelectorAll('[data-adm-wh-delete]').forEach(btn => {
btn.addEventListener('click', async () => {
if (!await uiModule.styledConfirm('Delete this webhook?', { confirmText: 'Delete', danger: true })) return;
await fetch(`/api/webhooks/${btn.dataset.admWhDelete}`, { method: 'DELETE', credentials: 'same-origin' }); loadWebhooks();
});
});
} catch (e) { list.innerHTML = 'Failed to load webhooks
'; }
}
function initWebhookForm() {
el('adm-whAddBtn').addEventListener('click', async () => {
const msg = el('adm-whMsg');
msg.textContent = ''; msg.className = '';
const name = el('adm-whName').value.trim();
const url = el('adm-whUrl').value.trim();
const secret = el('adm-whSecret').value.trim();
const events = Array.from(modalEl.querySelectorAll('.adm-wh-event:checked')).map(e => e.value).join(',');
if (!name) { msg.textContent = 'Name is required'; msg.className = 'admin-error'; return; }
if (!url) { msg.textContent = 'URL is required'; msg.className = 'admin-error'; return; }
if (!events) { msg.textContent = 'Select at least one event'; msg.className = 'admin-error'; return; }
const fd = new FormData();
fd.append('name', name); fd.append('url', url); fd.append('secret', secret); fd.append('events', events);
try {
const res = await fetch('/api/webhooks', { method: 'POST', body: fd, credentials: 'same-origin' });
if (res.ok) { msg.textContent = 'Webhook added'; msg.className = 'admin-success'; el('adm-whName').value = ''; el('adm-whUrl').value = ''; el('adm-whSecret').value = ''; loadWebhooks(); }
else { const d = await res.json(); msg.textContent = d.detail || 'Failed'; msg.className = 'admin-error'; }
} catch (e) { msg.textContent = 'Failed: ' + e.message; msg.className = 'admin-error'; }
});
}
/* ── Features ── */
const featureLabels = {
web_search: 'Web Search', deep_research: 'Deep Research',
memory: 'Memory', document_editor: 'Document Editor', rag: 'RAG Knowledge Base', sensitive_filter: 'Sensitive Info Filter',
gallery: 'Gallery'
};
async function loadFeatures() {
const container = el('adm-featureToggles');
try {
const res = await fetch('/api/auth/features', { credentials: 'same-origin' });
const features = await res.json();
container.innerHTML = Object.entries(featureLabels).map(([key, label]) => `
`).join('');
container.querySelectorAll('input[data-adm-feature]').forEach(toggle => {
toggle.addEventListener('change', async () => {
const body = {}; body[toggle.dataset.admFeature] = toggle.checked;
await fetch('/api/auth/features', { method: 'POST', credentials: 'same-origin', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(body) });
});
});
} catch (e) { container.innerHTML = 'Failed to load features
'; }
}
/* ── CalDAV Config ── */
function initCalDAV() {
const urlIn = el('caldav-url');
const userIn = el('caldav-user');
const passIn = el('caldav-pass');
const saveBtn = el('caldav-save-btn');
const testBtn = el('caldav-test-btn');
const status = el('caldav-status');
if (!urlIn || !saveBtn) return;
// Load current config
fetch(`${API_BASE}/api/calendar/config`, { credentials: 'same-origin' })
.then(r => r.json()).then(d => {
urlIn.value = d.caldav_url || '';
userIn.value = d.caldav_username || '';
passIn.value = d.caldav_password || '';
}).catch(() => {});
saveBtn.addEventListener('click', async () => {
status.textContent = 'Saving...';
try {
const res = await fetch(`${API_BASE}/api/calendar/config`, {
method: 'POST', credentials: 'same-origin',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ caldav_url: urlIn.value, caldav_username: userIn.value, caldav_password: passIn.value }),
});
const d = await res.json();
status.textContent = d.ok ? 'Saved' : 'Error';
status.style.color = d.ok ? 'var(--green)' : 'var(--red)';
} catch (e) { status.textContent = 'Error'; status.style.color = 'var(--red)'; }
setTimeout(() => { status.textContent = ''; status.style.color = ''; }, 3000);
});
testBtn.addEventListener('click', async () => {
status.textContent = 'Testing...';
try {
// Save first
await fetch(`${API_BASE}/api/calendar/config`, {
method: 'POST', credentials: 'same-origin',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ caldav_url: urlIn.value, caldav_username: userIn.value, caldav_password: passIn.value }),
});
const res = await fetch(`${API_BASE}/api/calendar/test`, { method: 'POST', credentials: 'same-origin' });
const d = await res.json();
status.textContent = d.ok ? `Connected (${d.calendars} calendars)` : `Failed: ${d.error}`;
status.style.color = d.ok ? 'var(--green)' : 'var(--red)';
} catch (e) { status.textContent = 'Error'; status.style.color = 'var(--red)'; }
setTimeout(() => { status.textContent = ''; status.style.color = ''; }, 5000);
});
}
/* ── Data Backup (export/import) ── */
function initBackup() {
el('adm-exportDataBtn').addEventListener('click', async () => {
const btn = el('adm-exportDataBtn');
const msg = el('adm-backupMsg');
btn.disabled = true; btn.textContent = 'Exporting...'; msg.textContent = '';
try {
const res = await fetch('/api/export', { credentials: 'same-origin' });
if (!res.ok) throw new Error('Export failed');
const blob = await res.blob();
const disposition = res.headers.get('Content-Disposition') || '';
const match = disposition.match(/filename=(.+)/);
const filename = match ? match[1] : 'odysseus_backup.json';
const a = document.createElement('a');
a.href = URL.createObjectURL(blob);
a.download = filename;
a.click();
URL.revokeObjectURL(a.href);
msg.textContent = 'Export downloaded.'; msg.className = 'admin-success';
} catch (e) { msg.textContent = 'Export failed: ' + e.message; msg.className = 'admin-error'; }
btn.disabled = false; btn.textContent = 'Export Data';
});
const fileInput = el('adm-importFile');
el('adm-importDataBtn').addEventListener('click', () => { fileInput.value = ''; fileInput.click(); });
fileInput.addEventListener('change', async () => {
const file = fileInput.files[0];
if (!file) return;
const msg = el('adm-backupMsg');
const btn = el('adm-importDataBtn');
btn.disabled = true; btn.textContent = 'Importing...'; msg.textContent = '';
try {
const text = (await file.text()).replace(/^\uFEFF/, '').trim();
let data;
try {
data = JSON.parse(text);
} catch (e) {
throw new Error('Invalid backup file: ' + e.message);
}
const res = await fetch('/api/import', {
method: 'POST', credentials: 'same-origin',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify(data),
});
const result = await res.json().catch(() => null);
if (!result) {
throw new Error(`Import failed: server returned ${res.status}`);
}
if (res.ok && result.ok) {
msg.textContent = result.message || 'Import successful.'; msg.className = 'admin-success';
} else {
msg.textContent = result.message || result.detail || 'Import failed'; msg.className = 'admin-error';
}
} catch (e) { msg.textContent = 'Import failed: ' + e.message; msg.className = 'admin-error'; }
btn.disabled = false; btn.textContent = 'Import Data';
});
}
/* ── Danger Zone ── */
function initDangerZone() {
// Per-category Danger Zone wipes. Each button declares its target
// via data-wipe-kind; one delegated handler handles double-confirm,
// POSTs to /api/admin/wipe/{kind}, and writes the result.
const _LABELS = {
chats: 'chats', memory: 'memory entries', skills: 'skills',
notes: 'notes', tasks: 'tasks', documents: 'documents',
gallery: 'gallery images', calendar: 'calendar items',
};
const _wipeMsg = el('adm-wipeMsg');
modalEl.querySelectorAll('[data-wipe-kind]').forEach(btn => {
btn.addEventListener('click', async () => {
const kind = btn.dataset.wipeKind;
const isAll = kind === '__all__';
const label = isAll ? 'data across every category' : (_LABELS[kind] || kind);
if (!await uiModule.styledConfirm(`Delete ALL ${label}? This cannot be undone.`, { confirmText: 'Delete', danger: true })) return;
if (!await uiModule.styledConfirm(`Really delete every one of your ${label}?`, { confirmText: isAll ? 'Yes, delete everything' : 'Yes, delete everything', danger: true })) return;
btn.disabled = true;
const prevHtml = btn.innerHTML;
btn.innerHTML = isAll ? 'Deleting all…' : 'Deleting…';
if (_wipeMsg) { _wipeMsg.textContent = ''; _wipeMsg.className = ''; }
try {
if (isAll) {
// Iterate every known category. Failures in one shouldn't stop
// the rest — record per-category counts and surface a summary.
const kinds = Object.keys(_LABELS);
const results = [];
for (const k of kinds) {
try {
const r = await fetch(`/api/admin/wipe/${k}`, { method: 'DELETE', credentials: 'same-origin' });
const d = await r.json().catch(() => ({}));
results.push({ k, ok: r.ok, count: d.count ?? 0, error: r.ok ? null : (d.detail || 'failed') });
} catch (e) {
results.push({ k, ok: false, count: 0, error: e.message });
}
}
const okCount = results.filter(r => r.ok).length;
const total = results.reduce((n, r) => n + (r.ok ? r.count : 0), 0);
const fails = results.filter(r => !r.ok).map(r => r.k);
if (_wipeMsg) {
if (!fails.length) {
_wipeMsg.textContent = `Deleted ${total} items across all ${okCount} categories.`;
_wipeMsg.className = 'admin-success';
} else {
_wipeMsg.textContent = `Deleted ${total} items; failed: ${fails.join(', ')}.`;
_wipeMsg.className = 'admin-error';
}
}
} else {
const res = await fetch(`/api/admin/wipe/${kind}`, { method: 'DELETE', credentials: 'same-origin' });
const data = await res.json().catch(() => ({}));
if (res.ok) {
if (_wipeMsg) { _wipeMsg.textContent = `Deleted ${data.count ?? 0} ${label}.`; _wipeMsg.className = 'admin-success'; }
} else {
if (_wipeMsg) { _wipeMsg.textContent = data.detail || 'Failed'; _wipeMsg.className = 'admin-error'; }
}
}
} catch (e) {
if (_wipeMsg) { _wipeMsg.textContent = 'Request failed: ' + e.message; _wipeMsg.className = 'admin-error'; }
}
btn.disabled = false; btn.innerHTML = prevHtml;
});
});
}
/* ═══════════════════════════════════════════
TERMINAL LOGS VIEWER
═══════════════════════════════════════════ */
let logsPollInterval = null;
let isLogsPolling = false;
let cachedLogs = [];
let logsAbortController = null;
function renderLogs(isAutoPoll = false) {
const consoleContainer = el('log-console-container');
const levelSelect = el('log-level-select');
const searchInput = el('log-search-input');
if (!consoleContainer) return;
const levelFilter = levelSelect ? levelSelect.value : 'ALL';
const searchQuery = searchInput ? searchInput.value.trim().toLowerCase() : '';
let logs = cachedLogs;
// Filter by level locally
if (levelFilter !== 'ALL') {
logs = logs.filter(line => line.includes(` - ${levelFilter} - `));
}
// Filter by search query locally
if (searchQuery) {
logs = logs.filter(line => line.toLowerCase().includes(searchQuery));
}
if (logs.length === 0) {
consoleContainer.innerHTML = 'No logs found matching current filters.
';
return;
}
// Preserve scroll position if user is reading previous logs
const atBottom = consoleContainer.scrollHeight - consoleContainer.scrollTop - consoleContainer.clientHeight < 40;
consoleContainer.innerHTML = logs.map(line => {
let levelClass = 'log-line-default';
if (line.includes(' - INFO - ')) {
levelClass = 'log-line-info';
} else if (line.includes(' - WARNING - ')) {
levelClass = 'log-line-warning';
} else if (line.includes(' - ERROR - ') || line.includes(' - CRITICAL - ')) {
levelClass = 'log-line-error';
} else if (line.includes(' - DEBUG - ')) {
levelClass = 'log-line-debug';
}
// XSS safe escape
const escaped = line
.replace(/&/g, '&')
.replace(//g, '>')
.replace(/"/g, '"')
.replace(/'/g, ''');
return `${escaped}
`;
}).join('');
if (!isAutoPoll || atBottom) {
consoleContainer.scrollTop = consoleContainer.scrollHeight;
}
}
async function loadLogs(isAutoPoll = false) {
const consoleContainer = el('log-console-container');
const limitSelect = el('log-limit-select');
if (!consoleContainer) return;
const limit = limitSelect ? limitSelect.value : 200;
if (logsAbortController) {
logsAbortController.abort();
}
logsAbortController = new AbortController();
const { signal } = logsAbortController;
try {
const res = await fetch(`/api/diagnostics/logs?limit=${limit}`, {
credentials: 'same-origin',
signal
});
if (!res.ok) {
if (!isAutoPoll) {
consoleContainer.innerHTML = '';
const errDiv = document.createElement('div');
errDiv.style.color = 'var(--red)';
errDiv.style.fontWeight = '600';
errDiv.textContent = `Failed to load logs: HTTP ${res.status}`;
consoleContainer.appendChild(errDiv);
}
return;
}
const data = await res.json();
if (data.status !== 'success' || !data.logs) {
if (!isAutoPoll) {
consoleContainer.innerHTML = '';
const errDiv = document.createElement('div');
errDiv.style.color = 'var(--red)';
errDiv.style.fontWeight = '600';
errDiv.textContent = 'Failed to parse logs data';
consoleContainer.appendChild(errDiv);
}
return;
}
cachedLogs = data.logs;
renderLogs(isAutoPoll);
} catch (err) {
if (err.name === 'AbortError') {
return; // Silently ignore deliberate abort
}
if (!isAutoPoll) {
consoleContainer.innerHTML = '';
const errDiv = document.createElement('div');
errDiv.style.color = 'var(--red)';
errDiv.style.fontWeight = '600';
errDiv.textContent = `Error retrieving logs: ${err.message}`;
consoleContainer.appendChild(errDiv);
}
} finally {
if (logsAbortController?.signal === signal) {
logsAbortController = null;
}
}
}
function startLogsPolling() {
if (isLogsPolling) return;
isLogsPolling = true;
const toggle = el('log-auto-refresh-toggle');
if (toggle) toggle.checked = true;
logsPollInterval = setInterval(() => {
const modal = el('settings-modal');
const systemPanel = el('settings-modal')?.querySelector('[data-settings-panel="system"]');
// Safe self-cleanup if modal or panel is hidden/closed
if (!modal || modal.classList.contains('hidden') || !systemPanel || systemPanel.classList.contains('hidden')) {
stopLogsPolling();
return;
}
loadLogs(true);
}, 3000);
}
function stopLogsPolling() {
if (!isLogsPolling) return;
isLogsPolling = false;
if (logsPollInterval) {
clearInterval(logsPollInterval);
logsPollInterval = null;
}
const toggle = el('log-auto-refresh-toggle');
if (toggle) toggle.checked = false;
}
function initLogsView() {
const refreshBtn = el('log-refresh-btn');
const levelSelect = el('log-level-select');
const limitSelect = el('log-limit-select');
const searchInput = el('log-search-input');
const autoRefreshToggle = el('log-auto-refresh-toggle');
if (refreshBtn) refreshBtn.addEventListener('click', () => loadLogs(false));
if (levelSelect) levelSelect.addEventListener('change', () => renderLogs(false));
if (limitSelect) limitSelect.addEventListener('change', () => loadLogs(false));
if (searchInput) searchInput.addEventListener('input', () => renderLogs(false));
if (autoRefreshToggle) {
autoRefreshToggle.addEventListener('change', (e) => {
if (e.target.checked) {
startLogsPolling();
} else {
stopLogsPolling();
}
});
}
// Initial fetch on view loading
loadLogs(false);
}
/* ═══════════════════════════════════════════
INIT & REFRESH
═══════════════════════════════════════════ */
function initAll() {
modalEl = el('settings-modal');
const inits = [
initSignupToggle, initAddUser, initEndpointForm, initMcpForm,
initCalDAV, initBackup, initDangerZone, initTokenForm, initLogsView,
() => settingsModule.initIntegrations()
];
for (const fn of inits) {
try { fn(); } catch (e) { console.error('Admin init error in', fn.name || 'anonymous', e); }
}
initialized = true;
refreshAll();
}
function refreshAll() {
loadUsers();
loadEndpoints();
loadBuiltinTools();
loadMcpServers();
loadTokens();
loadLogs(false);
}
/* ═══════════════════════════════════════════
PUBLIC API
═══════════════════════════════════════════ */
export function _initData() {
if (!initialized) initAll();
else refreshAll();
}
export function open(tab) {
_initData();
settingsModule.open(tab || 'services');
}
export function close() {
stopLogsPolling();
settingsModule.close();
}
const adminModule = { open, close, _initData, get _initialized() { return initialized; } };
export default adminModule;