diff --git a/CHANGELOG.md b/CHANGELOG.md
index 6f0bf97..2105b03 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -8,6 +8,34 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ## [Unreleased]
 
 ### Added
+- **DC-163: AI assistant that actually works — LLM intent engine + fixed
+  chat panel.** The 🤖 floating assistant was broken end-to-end: the
+  frontend read a nonexistent `data.data` envelope (every reply was
+  "Sorry, something went wrong"), the suggestion chips had nested-quote
+  onclick handlers (invalid JS, dead buttons), and the Deploy button called
+  a function that never existed. All three fixed. The router now runs TWO
+  engines behind one contract: an OpenAI-compatible LLM classifier (system
+  prompt embeds the LIVE 78-app catalog + wizard categories; conversation
+  history lets "yes" / "name it vault" resolve) with the original regex
+  patterns as the offline default AND automatic failover (HTTP error /
+  timeout / junk output → pattern answers, `engine` + `llmError` tell which
+  served). LLM output is schema-validated against closed vocabularies —
+  invented template ids are nulled, illegal intents coerced to unknown,
+  replies sanitized (control chars stripped, bounded) — the model can never
+  emit an action outside the platform's real set. Key storage: PUT
+  /api/v1/ai/settings writes to the ENCRYPTED credential store (never
+  config.json — GET /config echoes the raw file to browsers); GET never
+  returns the key; env AI_LLM_* / LLM_PROXY_URL fallback for headless
+  installs; POST /ai/settings/test proves the pipeline with one sample
+  classify; DELETE clears. Chat panel: flat-envelope parsing, data-attribute
+  chips with listeners, deploy button opens the REAL deploy modal via new
+  window.openDeployConfigFor(id) in app-selector.js, engine badge in the
+  header, ⚙ settings sub-panel. "Private YouTube for my living room TV" →
+  jellyfin deploy card, works with or without the LLM. 20 new tests
+  (engine selection, failover incl. AbortError timeout, closed-vocab
+  enforcement, history capping, key-never-echoed, settings CRUD + test,
+  flat envelope contract) on top of the 18 original pattern tests.
+  OpenAPI: 4 AI path entries. dist bundle rebuilt.
 - **DC-162 rev2: "Connect your AI" — spec Streamable HTTP MCP + one-click keys.**
   New primary-row button 🤖 Connect AI on the dashboard opens a modal that
   mints a dedicated `dk_` key and returns the standard MCP Streamable-HTTP
diff --git a/dashcaddy-api/__tests__/routes/ai-intent-engine.test.js b/dashcaddy-api/__tests__/routes/ai-intent-engine.test.js
new file mode 100644
index 0000000..c5a4568
--- /dev/null
+++ b/dashcaddy-api/__tests__/routes/ai-intent-engine.test.js
@@ -0,0 +1,368 @@
+/**
+ * DC-163: AI Intent Router — dual-engine tests.
+ *
+ * Covers:
+ *  - classify() engine selection: pattern-only when unconfigured, LLM when
+ *    credential store returns config, failover to pattern on HTTP errors /
+ *    timeouts / junk output.
+ *  - closed-vocabulary schema: invented template ids nulled; illegal intent
+ *    values coerced to 'unknown'; reply sanitized + length-bounded.
+ *  - enrich() response-shape contract the chat panel consumes.
+ *  - HTTP surface: POST /ai/intent flat envelope, /ai/settings GET/PUT/
+ *    DELETE/POST-test, key never echoed, capabilities engine reporting.
+ */
+
+'use strict';
+
+const express = require('express');
+const path = require('path');
+
+const intentMod = require('../../routes/ai-intent');
+
+// test key value built via concat (display-layer redactor note)
+const LLM_TEST_KEY = 'sk-' + 'testsecret123';
+
+function fakeCredStore(payload) {
+  const store = new Map();
+  if (payload !== undefined) store.set('ai:llm', payload);
+  return {
+    _store: store,
+    retrieve: jest.fn(async (k) => {
+      if (!store.has(k)) { throw new Error('not found'); }
+      return store.get(k);
+    }),
+    store: jest.fn(async (k, v) => { store.set(k, v); return { key: k, stored: true }; }),
+    delete: jest.fn(async (k) => { store.delete(k); return true; }),
+  };
+}
+
+function llmReplyFetch(content, calls) {
+  return async (url, opts) => {
+    if (calls) calls.push({ url, opts });
+    return {
+      ok: true, status: 200,
+      json: async () => ({ choices: [{ message: { content } }] }),
+    };
+  };
+}
+
+const silentLog = { info: jest.fn(), warn: jest.fn(), error: jest.fn() };
+
+describe('DC-163 classify engine selection', () => {
+  test('no credential store + no env → pattern engine, zero fetches', async () => {
+    let fired = 0;
+    const out = await intentMod.classify({
+      message: 'Deploy Plex',
+      history: [],
+      deps: { credentialManager: null, env: {}, fetchImpl: async () => { fired++; return {}; }, log: silentLog, timeoutMs: 1000 },
+    });
+    expect(out.engine).toBe('pattern');
+    expect(out.intent).toBe('deploy');
+    expect(out.appId).toBe('plex');
+    expect(fired).toBe(0);
+  });
+
+  test('credential store config → llm engine; off-catalog phrasing understood', async () => {
+    const calls = [];
+    const cm = fakeCredStore(JSON.stringify({ baseUrl: 'http://llm.test/v1', apiKey: LLM_TEST_KEY, model: 'test-model' }));
+    const fetchImpl = llmReplyFetch('{"intent":"deploy","appId":"jellyfin","reply":"Jellyfin it is"}', calls);
+    const out = await intentMod.classify({
+      message: 'I want a private YouTube for my living room TV',
+      history: [],
+      deps: { credentialManager: cm, env: {}, fetchImpl, log: silentLog, timeoutMs: 5000 },
+    });
+    expect(out.engine).toBe('llm');
+    expect(out.intent).toBe('deploy');
+    expect(out.appId).toBe('jellyfin'); // regex would have said 'unknown'
+    // prompt carries the real catalog
+    const sysPrompt = calls[0].opts.body ? JSON.parse(calls[0].opts.body).messages[0].content : '';
+    expect(sysPrompt).toContain('jellyfin');
+    expect(sysPrompt).toContain('radicale');
+    // auth header: Bearer with the stored key (shape check, value compared)
+    expect(calls[0].opts.headers.Authorization).toBe(`Bearer ${LLM_TEST_KEY}`);
+  });
+
+  test('hallucinated template id is nulled (closed vocabulary)', async () => {
+    const cm = fakeCredStore(JSON.stringify({ baseUrl: 'http://llm.test/v1', apiKey: LLM_TEST_KEY }));
+    const out = await intentMod.classify({
+      message: 'deploy YouTube Premium please',
+      history: [],
+      deps: { credentialManager: cm, env: {}, fetchImpl: llmReplyFetch('{"intent":"deploy","appId":"youtube-premium","reply":"ok"}'), log: silentLog, timeoutMs: 5000 },
+    });
+    expect(out.engine).toBe('llm');
+    expect(out.appId || null).toBeNull();
+  });
+
+  test('illegal intent string coerces to unknown', async () => {
+    const cm = fakeCredStore(JSON.stringify({ baseUrl: 'http://llm.test/v1', apiKey: LLM_TEST_KEY }));
+    const out = await intentMod.classify({
+      message: 'frobnicate the widget',
+      history: [],
+      deps: { credentialManager: cm, env: {}, fetchImpl: llmReplyFetch('{"intent":"rm -rf","appId":null,"reply":"hmm"}'), log: silentLog, timeoutMs: 5000 },
+    });
+    expect(out.intent).toBe('unknown');
+  });
+
+  test('LLM HTTP 500 → pattern failover with llmError recorded', async () => {
+    const cm = fakeCredStore(JSON.stringify({ baseUrl: 'http://llm.test/v1', apiKey: LLM_TEST_KEY }));
+    const fetchImpl = async () => ({ ok: false, status: 500, json: async () => ({}) });
+    const out = await intentMod.classify({
+      message: 'why is plex down',
+      history: [],
+      deps: { credentialManager: cm, env: {}, fetchImpl, log: silentLog, timeoutMs: 1000 },
+    });
+    expect(out.engine).toBe('pattern');
+    expect(out.intent).toBe('diagnose');
+    expect(out.serviceId).toBe('plex');
+    expect(out.llmError).toBeTruthy();
+  });
+
+  test('LLM timeout → AbortError surfaces as timeout failover', async () => {
+    const cm = fakeCredStore(JSON.stringify({ baseUrl: 'http://llm.test/v1', apiKey: LLM_TEST_KEY }));
+    const fetchImpl = (url, opts) => new Promise((_res, rej) => {
+      opts.signal.addEventListener('abort', () => { const e = new Error('aborted'); e.name = 'AbortError'; rej(e); });
+    });
+    const out = await intentMod.classify({
+      message: 'Back up everything',
+      history: [],
+      deps: { credentialManager: cm, env: {}, fetchImpl, log: silentLog, timeoutMs: 80 },
+    });
+    expect(out.engine).toBe('pattern');
+    expect(out.intent).toBe('backup');
+    expect(String(out.llmError)).toMatch(/timeout/i);
+  }, 10000);
+
+  test('markdown-fenced JSON + prefix prose is repaired and parsed', async () => {
+    const cm = fakeCredStore(JSON.stringify({ baseUrl: 'http://llm.test/v1', apiKey: LLM_TEST_KEY }));
+    const out = await intentMod.classify({
+      message: 'Block ads on my network',
+      history: [],
+      deps: { credentialManager: cm, env: {}, fetchImpl: llmReplyFetch('Sure! ```json\n{"intent":"recommend","appId":null,"categories":["home-network"],"reply":"AdGuard rules"}\n```'), log: silentLog, timeoutMs: 5000 },
+    });
+    expect(out.engine).toBe('llm');
+    expect(out.intent).toBe('recommend');
+    expect(out.llmReply).toBe('AdGuard rules');
+  });
+
+  test('reply control chars stripped and bounded', async () => {
+    const cm = fakeCredStore(JSON.stringify({ baseUrl: 'http://llm.test/v1', apiKey: LLM_TEST_KEY }));
+    const long = 'x'.repeat(2000) + '\u0000evil';
+    const out = await intentMod.classify({
+      message: 'what is deployed',
+      history: [],
+      deps: { credentialManager: cm, env: {}, fetchImpl: llmReplyFetch(JSON.stringify({ intent: 'list', reply: long })), log: silentLog, timeoutMs: 5000 },
+    });
+    expect(out.llmReply.length).toBeLessThanOrEqual(600);
+    expect(out.llmReply.indexOf('evil')).toBe(-1);
+    // eslint-disable-next-line no-control-regex -- deliberately asserting control chars were stripped
+    expect(out.llmReply).not.toMatch(new RegExp('[\\u0000-\\u001F]'));
+  });
+
+  test('history is role-filtered and capped at MAX_HISTORY', async () => {
+    const cm = fakeCredStore(JSON.stringify({ baseUrl: 'http://llm.test/v1', apiKey: LLM_TEST_KEY }));
+    const calls = [];
+    const fetchImpl = llmReplyFetch('{"intent":"deploy","appId":"gitea","reply":"ok"}', calls);
+    const hist = Array.from({ length: 20 }, (_, i) => ({ role: i % 3 === 2 ? 'system' : (i % 2 ? 'user' : 'assistant'), content: 'c' + i }));
+    await intentMod.classify({ message: 'yes deploy it', history: hist, deps: { credentialManager: cm, env: {}, fetchImpl, log: silentLog, timeoutMs: 5000 } });
+    const msgs = JSON.parse(calls[0].opts.body).messages;
+    expect(msgs.length).toBeLessThanOrEqual(8); // system + ≤6 history + user
+    expect(msgs.filter(m => m.role === 'system').length).toBe(1); // injected 'system' roles dropped
+  });
+
+  test('env AI_LLM_* config works without credential store', async () => {
+    const out = await intentMod.classify({
+      message: 'Deploy Plex',
+      history: [],
+      deps: { credentialManager: null, env: { AI_LLM_BASE_URL: 'http://llm.test/v1', AI_LLM_API_KEY: '***' + 'envkey', AI_LLM_MODEL: 'env-model' }, fetchImpl: llmReplyFetch('{"intent":"deploy","appId":"uptime-kuma","reply":"sure"}'), log: silentLog, timeoutMs: 5000 },
+    });
+    expect(out.engine).toBe('llm');
+    expect(out.model).toBe('env-model');
+    expect(out.appId).toBe('uptime-kuma'); // NOT in the old regex list — catalog-wide
+  });
+
+  test('LLM disagreement: pattern said recommend, LLM says deploy → deploy response rebuilt', async () => {
+    const cm = fakeCredStore(JSON.stringify({ baseUrl: 'http://llm.test/v1', apiKey: LLM_TEST_KEY }));
+    const out = await intentMod.classify({
+      message: 'I want to stream movies', // regex: recommend
+      history: [],
+      deps: { credentialManager: cm, env: {}, fetchImpl: llmReplyFetch('{"intent":"deploy","appId":"jellyfin","reply":"Jellyfin streams movies"}'), log: silentLog, timeoutMs: 5000 },
+    });
+    expect(out.intent).toBe('deploy');
+    expect(out.appId).toBe('jellyfin');
+    const enriched = intentMod.enrich({ ...out });
+    expect(enriched.response.message).toBeTruthy();
+    expect(enriched.response.appId).toBe('jellyfin');
+    expect(enriched.deployPlan.templateId).toBe('jellyfin');
+    expect(enriched.deployPlan.body.port).toBe(8096); // real template defaultPort, not null
+  });
+});
+
+// ─── HTTP surface ────────────────────────────────────────────────────────────
+function buildRouter({ credentialManager = fakeCredStore(undefined), env = {}, fetchImpl = null } = {}) {
+  jest.resetModules();
+  const mod = require('../../routes/ai-intent');
+  const asyncHandler = (fn) => async (req, res, next) => {
+    try { await fn(req, res, next); } catch (e) { next(e); }
+  };
+  const errorResponse = (res, code, msg, extra) => res.status(code).json({ success: false, error: msg, ...(extra || {}) });
+
+  const app = express();
+  app.use(express.json());
+  app.use('/api/v1', mod({ asyncHandler, errorResponse, log: silentLog, siteConfig: null, credentialManager, fetchImpl, env }));
+  app.use((err, req, res, next) => { res.status(err.statusCode || 500).json({ success: false, error: err.message }); }); // eslint-disable-line no-unused-vars
+  return app;
+}
+
+async function start(app) {
+  const server = await new Promise((resolve) => {
+    const s = app.listen(0, '127.0.0.1', () => resolve(s));
+  });
+  return { server, base: `http://127.0.0.1:${server.address().port}/api/v1` };
+}
+
+describe('DC-163 ai HTTP routes', () => {
+  test('POST /ai/intent — flat ok() envelope (no data.data wrapper)', async () => {
+    const app = buildRouter();
+    const { server, base } = await start(app);
+    try {
+      const res = await fetch(`${base}/ai/intent`, {
+        method: 'POST', headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ message: 'Deploy Plex' }),
+      });
+      const body = await res.json();
+      expect(res.status).toBe(200);
+      expect(body.success).toBe(true);
+      expect(body.intent).toBe('deploy');
+      expect(body.engine).toBe('pattern');
+      expect(body.response.message).toBeTruthy();
+      expect(body.response.appId).toBe('plex');
+      expect(body.deployPlan.body.name).toBe('Plex');
+      expect(body.timestamp).toBeTruthy();
+    } finally { server.close(); }
+  });
+
+  test('POST /ai/intent — 400 on missing/non-string message', async () => {
+    const app = buildRouter();
+    const { server, base } = await start(app);
+    try {
+      for (const bad of [{}, { message: '' }, { message: 42 }, { message: '   '}]) {
+        const res = await fetch(`${base}/ai/intent`, { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(bad) });
+        expect(res.status).toBe(400);
+      }
+    } finally { server.close(); }
+  });
+
+  test('POST /ai/intent — message over 1000 chars is truncated, not rejected', async () => {
+    const app = buildRouter();
+    const { server, base } = await start(app);
+    try {
+      const res = await fetch(`${base}/ai/intent`, {
+        method: 'POST', headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ message: 'Deploy Plex ' + 'z'.repeat(1500) }),
+      });
+      expect(res.status).toBe(200);
+      const body = await res.json();
+      expect(body.message.length).toBeLessThanOrEqual(1000);
+      expect(body.intent).toBe('deploy');
+    } finally { server.close(); }
+  });
+
+  test('GET /ai/settings — reports configuration WITHOUT the api key', async () => {
+    const cm = fakeCredStore(JSON.stringify({ baseUrl: 'http://llm.test/v1', apiKey: LLM_TEST_KEY, model: 'test-model' }));
+    const app = buildRouter({ credentialManager: cm });
+    const { server, base } = await start(app);
+    try {
+      const res = await fetch(`${base}/ai/settings`);
+      const body = await res.json();
+      expect(body.success).toBe(true);
+      expect(body.configured).toBe(true);
+      expect(body.source).toBe('credential-store');
+      expect(body.model).toBe('test-model');
+      const raw = JSON.stringify(body);
+      expect(raw).not.toContain(LLM_TEST_KEY);
+      expect(body.hasApiKey).toBe(true);
+    } finally { server.close(); }
+  });
+
+  test('PUT /ai/settings — stores in credential store; requires baseUrl+apiKey on first save', async () => {
+    const cm = fakeCredStore(undefined);
+    const app = buildRouter({ credentialManager: cm });
+    const { server, base } = await start(app);
+    try {
+      // missing key → 400
+      const r1 = await fetch(`${base}/ai/settings`, { method: 'PUT', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ baseUrl: 'http://llm.test/v1' }) });
+      expect(r1.status).toBe(400);
+      // bad baseUrl → 400
+      const r2 = await fetch(`${base}/ai/settings`, { method: 'PUT', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ baseUrl: 'ftp://x', apiKey: LLM_TEST_KEY }) });
+      expect(r2.status).toBe(400);
+      // valid → stored encrypted (credentialManager.store), response never echoes key
+      const r3 = await fetch(`${base}/ai/settings`, { method: 'PUT', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ baseUrl: 'http://llm.test/v1', model: 'test-model', apiKey: LLM_TEST_KEY }) });
+      const b3 = await r3.json();
+      expect(r3.status).toBe(200);
+      expect(b3.saved).toBe(true);
+      expect(JSON.stringify(b3)).not.toContain(LLM_TEST_KEY);
+      const stored = JSON.parse(cm._store.get('ai:llm'));
+      expect(stored.apiKey).toBe(LLM_TEST_KEY);
+      // partial update keeps stored key
+      const r4 = await fetch(`${base}/ai/settings`, { method: 'PUT', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ model: 'new-model' }) });
+      expect(r4.status).toBe(200);
+      expect(JSON.parse(cm._store.get('ai:llm')).apiKey).toBe(LLM_TEST_KEY);
+      expect(JSON.parse(cm._store.get('ai:llm')).model).toBe('new-model');
+    } finally { server.close(); }
+  });
+
+  test('DELETE /ai/settings — clears stored config', async () => {
+    const cm = fakeCredStore(JSON.stringify({ baseUrl: 'http://llm.test/v1', apiKey: LLM_TEST_KEY }));
+    const app = buildRouter({ credentialManager: cm });
+    const { server, base } = await start(app);
+    try {
+      const res = await fetch(`${base}/ai/settings`, { method: 'DELETE' });
+      expect(res.status).toBe(200);
+      expect(cm._store.has('ai:llm')).toBe(false);
+      const after = await (await fetch(`${base}/ai/settings`)).json();
+      expect(after.configured).toBe(false);
+    } finally { server.close(); }
+  });
+
+  test('POST /ai/settings/test — end-to-end probe returns sample intent, no key', async () => {
+    const cm = fakeCredStore(JSON.stringify({ baseUrl: 'http://llm.test/v1', apiKey: LLM_TEST_KEY, model: 'test-model' }));
+    const fetchImpl = llmReplyFetch('{"intent":"backup","appId":null,"reply":"Backup it is"}');
+    const app = buildRouter({ credentialManager: cm, fetchImpl });
+    const { server, base } = await start(app);
+    try {
+      const res = await fetch(`${base}/ai/settings/test`, { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: '{}' });
+      const body = await res.json();
+      expect(body.ok).toBe(true);
+      expect(body.engine).toBe('llm');
+      expect(body.sample.intent).toBe('backup');
+      expect(JSON.stringify(body)).not.toContain(LLM_TEST_KEY);
+    } finally { server.close(); }
+  });
+
+  test('POST /ai/settings/test — failure degrades to ok:false with reason (never throws)', async () => {
+    const cm = fakeCredStore(JSON.stringify({ baseUrl: 'http://llm.test/v1', apiKey: LLM_TEST_KEY }));
+    const app = buildRouter({ credentialManager: cm, fetchImpl: async () => { throw new Error('ECONNREFUSED'); } });
+    const { server, base } = await start(app);
+    try {
+      const res = await fetch(`${base}/ai/settings/test`, { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: '{}' });
+      expect(res.status).toBe(200);
+      const body = await res.json();
+      expect(body.ok).toBe(false);
+      expect(body.reason).toMatch(/ECONNREFUSED/);
+    } finally { server.close(); }
+  });
+
+  test('GET /ai/capabilities — engine reflects live configuration', async () => {
+    const app = buildRouter();
+    const { server, base } = await start(app);
+    try {
+      const body = await (await fetch(`${base}/ai/capabilities`)).json();
+      expect(body.success).toBe(true);
+      expect(body.engine).toBe('pattern');
+      expect(body.llm.configured).toBe(false);
+      expect(body.llm.howToEnable).toMatch(/credential store/);
+      expect(body.intents).toContain('deploy');
+      expect(body.capabilities.length).toBeGreaterThanOrEqual(6);
+    } finally { server.close(); }
+  });
+});
diff --git a/dashcaddy-api/openapi.yaml b/dashcaddy-api/openapi.yaml
index 2f4a676..aff7750 100644
--- a/dashcaddy-api/openapi.yaml
+++ b/dashcaddy-api/openapi.yaml
@@ -7773,6 +7773,71 @@ paths:
         '200':
           description: Probe result (ok flag inside — transport errors are reported, not thrown)
 
+  /api/v1/ai/intent:
+    post:
+      tags: [AI]
+      summary: Natural language → structured intent
+      description: >
+        Dual-engine intent router. LLM engine (OpenAI-compatible classifier,
+        configured via /ai/settings or AI_LLM_* env) resolves against the
+        full app catalog and conversation history; pattern engine serves
+        offline and as automatic failover (engine field tells which answered;
+        llmError records the failover reason). Output is schema-validated
+        against closed vocabularies — the model can never emit an action or
+        template id outside the platform's real sets. Response is the flat
+        ok() envelope: {success, intent, confidence, action, engine, appId?,
+        serviceId?, response{message,appId?,appName?,recommendations?,
+        suggestions?,disclaimer?}, deployPlan?, wizardCall?, timestamp}.
+      responses:
+        '200':
+          description: Structured intent (flat envelope)
+        '400':
+          description: message (non-empty string) required
+
+  /api/v1/ai/capabilities:
+    get:
+      tags: [AI]
+      summary: What the assistant can do + live engine status
+      responses:
+        '200':
+          description: Intent list, capabilities, engine (llm|pattern), llm config status (key never included)
+
+  /api/v1/ai/settings:
+    get:
+      tags: [AI]
+      summary: LLM assistant configuration (key never echoed)
+      responses:
+        '200':
+          description: configured, source, baseUrl, model, hasApiKey
+    put:
+      tags: [AI]
+      summary: Store LLM config in the encrypted credential store
+      description: >
+        body {baseUrl?, model?, apiKey?}. Stored under credential key
+        'ai:llm' — NEVER config.json (GET /config returns the raw file to
+        the browser). Blank apiKey keeps the stored one. First save
+        requires baseUrl + apiKey. baseUrl must be http(s).
+      responses:
+        '200':
+          description: Saved (response never contains the key)
+        '400':
+          description: Invalid baseUrl or missing required fields
+    delete:
+      tags: [AI]
+      summary: Remove stored LLM config (falls back to env/pattern)
+      responses:
+        '200':
+          description: Cleared
+
+  /api/v1/ai/settings/test:
+    post:
+      tags: [AI]
+      summary: One-shot classifier probe (proves the LLM end-to-end)
+      description: Sends a fixed sample message through the configured LLM and returns the parsed intent. Failures answer ok:false with a reason (200), never throw.
+      responses:
+        '200':
+          description: '{ok, engine, model?, sample?{intent,reply}} or {ok:false, reason}'
+
   /api/v1/mcp:
     post:
       tags: [MCP]
diff --git a/dashcaddy-api/routes/ai-intent.js b/dashcaddy-api/routes/ai-intent.js
index f39be3a..bc9a7d8 100644
--- a/dashcaddy-api/routes/ai-intent.js
+++ b/dashcaddy-api/routes/ai-intent.js
@@ -5,18 +5,235 @@
  * that can be executed against the DashCaddy API.
  *
  * POST /api/v1/ai/intent
- *   Body: { message: "I want to stream movies", context: {} }
- *   Returns: { intent, confidence, actions, followup }
+ *   Body: { message: "I want to stream movies", history?: [{role,content}] }
+ *   Returns: { intent, confidence, action, engine, response, appId?, … }
  *
- * The intent router uses pattern matching (not an LLM call) so it works
- * instantly and offline. For complex queries, it can delegate to an
- * external LLM via the LLM_PROXY_URL env var.
+ * Two engines, one contract:
+ *   1. LLM engine (default when configured): a small OpenAI-compatible model
+ *      classifies the message into the DashCaddy intent vocabulary with the
+ *      LIVE app catalog + wizard categories as the candidate list — so any
+ *      of the 78 templates (and follow-ups like "name it vault") work,
+ *      including ones the old regex list never knew about.
+ *      Configured at PUT /api/v1/ai/settings (encrypted credential store,
+ *      key 'ai:llm') with env fallbacks AI_LLM_* / LLM_PROXY_URL. NEVER
+ *      config.json: GET /config returns the raw file to the browser.
+ *      The upstream call uses the GLOBAL fetch with an AbortController —
+ *      deliberately NOT ctx.fetchT, whose https path sets
+ *      rejectUnauthorized:false for self-signed .sami certs; an EXTERNAL
+ *      LLM API must get full TLS verification.
+ *   2. Pattern engine (instant, offline, zero-config): the original regex
+ *      library. Used when no LLM is configured, and as the failover when the
+ *      LLM call fails, times out, or returns an unrepairable shape.
+ *   The response carries `engine` so callers can show what actually served.
+ *
+ * Injection-safety model (DC-163): the LLM is given data-finding tasks only.
+ * Output is schema-validated against closed vocabularies; free text is
+ * bounded and stripped of control chars. The model can NEVER produce an
+ * action string outside the known action set or a template id outside the
+ * catalog. The reply text is displayed client-side via textContent only.
+ * No LLM output is ever executed.
  */
 
+'use strict';
+
 const express = require('express');
 const { ok, errorResponse } = require('../src/utils/responses');
+const { APP_TEMPLATES } = require('../src/docker/app-templates');
 
-// ─── Intent Pattern Library ─────────────────────────────────────────────────
+// ─── Vocabularies (closed sets — the LLM may only choose from these) ───────
+
+const INTENTS = ['deploy', 'recommend', 'diagnose', 'health', 'list', 'backup', 'unknown'];
+
+const ACTIONS_BY_INTENT = {
+  deploy: 'dashcaddy_deploy_app',
+  recommend: 'dashcaddy_wizard_recommend',
+  diagnose: 'dashcaddy_diagnose',
+  health: 'dashcaddy_system_health',
+  list: 'dashcaddy_list_services',
+  backup: 'dashcaddy_create_backup',
+  unknown: null,
+};
+
+const RECOMMEND_CATEGORIES = ['media-streaming', 'file-sync', 'home-network', 'smart-home', 'development', 'monitoring'];
+const TEMPLATE_IDS = Object.keys(APP_TEMPLATES);
+
+const MAX_INPUT = 1000;        // user message cap (chars)
+const MAX_REPLY = 600;         // LLM reply cap (chars)
+const MAX_HISTORY = 6;         // prior turns sent to the LLM
+const LLM_TIMEOUT_MS = 8000;   // per-call deadline
+
+// ─── Text sanitizer: strip control chars; no HTML filtering needed because
+//     the chat panel renders replies with textContent only. ─────────────────
+function sanitizeText(s, max = MAX_REPLY) {
+  if (typeof s !== 'string') return '';
+  // eslint-disable-next-line no-control-regex
+  return s.replace(/[\u0000-\u001F\u007F]/g, ' ').replace(/\s+/g, ' ').trim().slice(0, max);
+}
+
+function normId(v) {
+  return typeof v === 'string' ? v.toLowerCase().replace(/[\s_]+/g, '-') : null;
+}
+
+// ─── Candidate catalog for the LLM prompt ──────────────────────────────────
+function catalogBlock(limit = 80) {
+  const tpl = TEMPLATE_IDS.slice(0, limit).map((id) => {
+    const t = APP_TEMPLATES[id];
+    return `- ${id}: ${t.name || id} (${(t.description || '').split(/[.!]/)[0].slice(0, 90)})`;
+  }).join('\n');
+  const cats = RECOMMEND_CATEGORIES.map((c) => `- ${c}`).join('\n');
+  return { tpl, cats };
+}
+
+function buildSystemPrompt() {
+  const { tpl, cats } = catalogBlock();
+  return 'You are the intent classifier for DashCaddy, a self-hosting dashboard. ' +
+    'Read the user message (and conversation history) and output ONLY a minified JSON object, no markdown:\n' +
+    '{"intent":"deploy|recommend|diagnose|health|list|backup|unknown",' +
+    '"appId":"<template id or null>","serviceId":"<service name or null>",' +
+    '"categories":["<wizard categories>"],"reply":"<short friendly sentence>"}\n' +
+    'Rules:\n' +
+    '- intent=deploy when the user wants to install/host/launch/run a specific app (including "set it up", "yes go"). Use history to resolve pronouns.\n' +
+    '- appId MUST be one of the template ids below (exact id), else null. Never invent ids.\n' +
+    '- intent=recommend when the user states a goal without naming an app; categories from the wizard list.\n' +
+    '- diagnose for problems ("why is X down"), health for status questions, list for inventory questions, backup for backup requests, unknown otherwise.\n' +
+    '- reply: at most 160 characters, plain text, no markdown, no links.\n' +
+    'Template ids:\n' + tpl + '\nWizard categories:\n' + cats;
+}
+
+// ─── OpenAI-compatible chat call ───────────────────────────────────────────
+async function callLlm(deps, cfg, messages) {
+  const doFetch = deps.fetchImpl || fetch;
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), deps.timeoutMs || LLM_TIMEOUT_MS);
+  try {
+    const res = await doFetch(`${cfg.baseUrl.replace(/\/+$/, '')}/chat/completions`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${cfg.apiKey}`,
+      },
+      body: JSON.stringify({
+        model: cfg.model,
+        messages,
+        temperature: 0,
+        max_tokens: 300,
+      }),
+      signal: controller.signal,
+    });
+    if (!res.ok) {
+      throw new Error(`LLM HTTP ${res.status}`);
+    }
+    const data = await res.json();
+    const content = data && data.choices && data.choices[0] &&
+      data.choices[0].message && data.choices[0].message.content;
+    if (typeof content !== 'string' || !content.trim()) {
+      throw new Error('LLM empty completion');
+    }
+    return content;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+// ─── Parse + repair + schema-validate the LLM output ───────────────────────
+function repairParsed(raw) {
+  // Deterministic corrections for common small-model drift BEFORE schema.
+  let out = raw.replace(/```(json)?/gi, '').trim();
+  const first = out.indexOf('{');
+  const last = out.lastIndexOf('}');
+  if (first !== -1 && last > first) out = out.slice(first, last + 1);
+  return out;
+}
+
+function validateParsed(parsed) {
+  if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) return null;
+  let intent = typeof parsed.intent === 'string' ? parsed.intent.toLowerCase() : null;
+  if (!INTENTS.includes(intent)) {
+    // drift repair: unknown-ish values → 'unknown'
+    intent = 'unknown';
+  }
+  const appId = normId(parsed.appId);
+  const serviceId = normId(parsed.serviceId);
+  const categories = Array.isArray(parsed.categories)
+    ? parsed.categories.map((c) => (typeof c === 'string' ? c.toLowerCase() : null)).filter((c) => c && RECOMMEND_CATEGORIES.includes(c))
+    : [];
+  return {
+    intent,
+    appId: appId && TEMPLATE_IDS.includes(appId) ? appId : null,
+    serviceId: serviceId || null,
+    categories,
+    reply: sanitizeText(parsed.reply, MAX_REPLY),
+  };
+}
+
+// ─── Merge validated LLM fields onto the pattern result ────────────────────
+// Pattern stays the structural base (known-good shapes); LLM contributes the
+// semantic understanding. appId is never LOST silently when both engines
+// disagree — the LLM candidate wins if it is a valid catalog id, because the
+// LLM saw the full 78-app catalog while regex knows only its hardcoded list.
+function mergeIntent(patternResult, llm) {
+  const merged = { ...patternResult };
+  const intentChanged = llm.intent !== patternResult.intent;
+  merged.intent = llm.intent;
+  merged.action = ACTIONS_BY_INTENT[llm.intent] || patternResult.action || null;
+  // If the LLM routed to a DIFFERENT intent than the pattern did, the
+  // pattern's canned response object belongs to the old intent — drop it
+  // and let enrich() rebuild the shape for the new one (with llmReply text).
+  if (intentChanged) merged.response = null;
+  if (llm.appId) merged.appId = llm.appId;
+  if (llm.serviceId && !merged.serviceId) merged.serviceId = llm.serviceId;
+  if (llm.intent === 'recommend') {
+    merged.categories = (llm.categories && llm.categories.length) ? llm.categories : (patternResult.categories || ['media-streaming']);
+  }
+  if (llm.reply) merged.llmReply = llm.reply;
+  return merged;
+}
+
+const DEFAULT_INTENT_MESSAGES = {
+  deploy: 'Ready to deploy.',
+  recommend: 'Here are some suggestions:',
+  diagnose: 'Let me check what\'s going on...',
+  health: 'Checking system health...',
+  list: 'Here are your services:',
+  backup: 'Creating a full system backup now...',
+  unknown: 'I\'m not sure what you\'d like to do — try the app catalog, or rephrase.',
+};
+
+// ─── Runtime config resolution ─────────────────────────────────────────────
+// Priority: encrypted credential store (self-service Settings UI, key
+// 'ai:llm') → env (AI_LLM_* / LLM_PROXY_URL). NEVER config.json: its GET
+// endpoint returns the raw file to the browser, so secrets must not live
+// there. Env fallback keeps headless installs working without the UI.
+async function getLlmConfig(deps) {
+  const env = deps.env || {};
+  let stored = null;
+  if (deps.credentialManager) {
+    try {
+      const raw = await deps.credentialManager.retrieve('ai:llm');
+      if (raw) stored = typeof raw === 'string' ? JSON.parse(raw) : raw;
+    } catch (_) { /* not stored yet — env fallback */ }
+  }
+  const baseUrl = ((stored && stored.baseUrl) || env.AI_LLM_BASE_URL || env.LLM_PROXY_URL || '').trim();
+  const apiKey = ((stored && stored.apiKey) || env.AI_LLM_API_KEY || env.LLM_PROXY_API_KEY || '').trim();
+  const model = ((stored && stored.model) || env.AI_LLM_MODEL || 'gpt-4o-mini').trim();
+  if (!baseUrl || !apiKey) return null;
+  if (!/^https?:\/\//i.test(baseUrl)) return null;
+  const source = (stored && stored.baseUrl && stored.apiKey) ? 'credential-store' : 'env';
+  return { baseUrl, apiKey, model, source };
+}
+// sync alias retained for pure-callers/tests that never touch the store
+function resolveLlmConfig({ env = {}, site = null } = {}) {
+  const ai = (site && site.ai) || {};
+  const llm = ai.llm || {};
+  const baseUrl = (llm.baseUrl || env.AI_LLM_BASE_URL || env.LLM_PROXY_URL || '').trim();
+  const apiKey = (llm.apiKey || env.AI_LLM_API_KEY || env.LLM_PROXY_API_KEY || '').trim();
+  const model = (llm.model || env.AI_LLM_MODEL || 'gpt-4o-mini').trim();
+  if (!baseUrl || !apiKey) return null;
+  if (!/^https?:\/\//i.test(baseUrl)) return null;
+  return { baseUrl, apiKey, model };
+}
+
+// ─── Intent Pattern Library (engine 2 — offline fallback; unchanged shapes) ─
 
 const INTENT_PATTERNS = [
   // ── Deploy intents ──
@@ -142,7 +359,6 @@ const INTENT_PATTERNS = [
     ],
     action: 'dashcaddy_diagnose',
     extractService: (msg) => {
-      // Try to extract service name from "why is X down" patterns
       const match = msg.match(/(?:why is |is |)(\w+)\s+(?:down|slow|broken|not working|failing|crashed)/i);
       if (match) return match[1].toLowerCase();
       return null;
@@ -193,12 +409,9 @@ const INTENT_PATTERNS = [
   },
 ];
 
-// ─── Intent Router ──────────────────────────────────────────────────────────
+// ─── Pattern engine (pure, sync — the public routeIntent contract) ─────────
 
 function routeIntent(message) {
-  const msg = message.toLowerCase().trim();
-
-  // Try each intent pattern
   for (const intent of INTENT_PATTERNS) {
     for (const pattern of intent.patterns) {
       if (pattern.test(message)) {
@@ -210,19 +423,14 @@ function routeIntent(message) {
           response: typeof intent.response === 'function' ? intent.response(message) : null,
         };
 
-        // Extract app name for deploy intents
         if (intent.extractApp) {
           const app = intent.extractApp(message);
           if (app) result.appId = app;
         }
-
-        // Extract service name for diagnose intents
         if (intent.extractService) {
           const service = intent.extractService(message);
           if (service) result.serviceId = service;
         }
-
-        // Suggest categories for recommend intents
         if (intent.suggestCategories) {
           result.categories = intent.suggestCategories;
         }
@@ -232,7 +440,6 @@ function routeIntent(message) {
     }
   }
 
-  // No match — return a fallback that suggests using the catalog
   return {
     intent: 'unknown',
     confidence: 0.3,
@@ -251,81 +458,222 @@ function routeIntent(message) {
   };
 }
 
+// ─── Enrichment shared by both engines (plans, wizard calls, reply merge) ──
+function enrich(result) {
+  if (result.intent === 'deploy' && result.appId) {
+    const tpl = APP_TEMPLATES[result.appId];
+    result.appName = (tpl && tpl.name) || result.appId;
+    result.deployPlan = {
+      templateId: result.appId,
+      endpoint: 'POST /api/v1/discover/adopt',
+      body: {
+        containerId: null, // set after container creation
+        serviceId: result.appId,
+        name: result.appName,
+        port: (tpl && tpl.defaultPort) || null, // from template when known
+        generateDns: true,
+        generateRoute: true,
+      },
+      nextSteps: [
+        `Search catalog: GET /api/v1/catalog/search?q=${encodeURIComponent(result.appId)}`,
+        `Get template: GET /api/v1/catalog/${encodeURIComponent(result.appId)}`,
+        'Deploy: POST /api/v1/discover/adopt',
+      ],
+    };
+    const baseMsg = result.response && result.response.message
+      ? result.response.message
+      : (result.llmReply || DEFAULT_INTENT_MESSAGES.deploy);
+    result.response = { ...(result.response || {}), message: baseMsg, appId: result.appId, appName: result.appName };
+  } else if (result.intent === 'recommend' && result.categories) {
+    result.wizardCall = {
+      endpoint: 'POST /api/v1/wizard/recommend',
+      body: { categories: result.categories, hardwareProfile: 'medium' },
+    };
+    // pattern canned recs stay (they're curated); LLM reply rides along as
+    // llmReply for the UI's secondary line, and a message exists either way.
+    result.response = { ...(result.response || {}), message: (result.response && result.response.message) || result.llmReply || DEFAULT_INTENT_MESSAGES.recommend };
+    if (result.llmReply) result.response.llmReply = result.llmReply;
+  } else if (result.intent !== 'deploy') {
+    const baseMsg = (result.response && result.response.message)
+      ? result.response.message
+      : (result.llmReply || DEFAULT_INTENT_MESSAGES[result.intent] || DEFAULT_INTENT_MESSAGES.unknown);
+    result.response = { ...(result.response || {}), message: baseMsg, suggestions: (result.response && result.response.suggestions) || undefined };
+  }
+  return result;
+}
+
+// ─── Classification orchestration ──────────────────────────────────────────
+async function classify({ message, history, deps }) {
+  const pattern = routeIntent(message);
+  const cfg = await getLlmConfig(deps);
+  if (!cfg) {
+    return { ...pattern, engine: 'pattern' };
+  }
+
+  const safeHistory = (Array.isArray(history) ? history : [])
+    .filter((h) => h && (h.role === 'user' || h.role === 'assistant') && typeof h.content === 'string')
+    .slice(-MAX_HISTORY);
+  const messages = [
+    { role: 'system', content: buildSystemPrompt() },
+    ...safeHistory,
+    { role: 'user', content: message },
+  ];
+
+  try {
+    const content = await callLlm(deps, cfg, messages);
+    const parsed = JSON.parse(repairParsed(content));
+    const validated = validateParsed(parsed);
+    if (!validated) throw new Error('LLM output failed schema validation');
+    deps.log.info('ai-intent', 'llm classified', { intent: validated.intent, appId: validated.appId });
+    const merged = mergeIntent(pattern, validated);
+    return { ...merged, engine: 'llm', model: cfg.model };
+  } catch (e) {
+    const reason = (e && e.name === 'AbortError') ? 'timeout' : (e && e.message) || 'unknown';
+    deps.log.warn('ai-intent', 'llm unavailable — pattern fallback', { reason: String(reason).slice(0, 200) });
+    return { ...pattern, engine: 'pattern', llmError: String(reason).slice(0, 200) };
+  }
+}
+
 // ─── Express Route ──────────────────────────────────────────────────────────
 
-module.exports = function({ asyncHandler }) {
+module.exports = function ({ asyncHandler, siteConfig = null, log = console, fetchImpl = null, env = process.env, credentialManager = null }) {
   const wrap = asyncHandler || ((fn) => (req, res, next) => Promise.resolve(fn(req, res, next)).catch(next));
   const router = express.Router();
+  const deps = {
+    siteConfig,
+    credentialManager,
+    log: (log && log.info && log.warn) ? log : { info: () => {}, warn: () => {}, error: () => {} },
+    fetchImpl,
+    env,
+    timeoutMs: Number(env.AI_LLM_TIMEOUT_MS) || LLM_TIMEOUT_MS,
+  };
 
   /**
-   * POST /api/v1/ai/intent
-   *
-   * Natural language → structured action plan
+   * POST /api/v1/ai/intent — natural language → structured action plan
    */
   router.post('/ai/intent', wrap(async (req, res) => {
     const { message, context = {} } = req.body || {};
+    let history = Array.isArray(req.body && req.body.history) ? req.body.history : [];
 
-    if (!message || typeof message !== 'string') {
+    if (!message || typeof message !== 'string' || !message.trim()) {
       return errorResponse(res, 400, 'message (string) is required');
     }
+    const cleanMessage = message.trim().slice(0, MAX_INPUT);
 
-    const result = routeIntent(message);
+    // History: keep only role/content string pairs from the client (the
+    // panel's own transcript), bounded and sanitized. Prompt-injection is
+    // contained by the closed-vocabulary schema, not by trusting this data.
+    history = history
+      .filter((h) => h && (h.role === 'user' || h.role === 'assistant') && typeof h.content === 'string')
+      .slice(-MAX_HISTORY)
+      .map((h) => ({ role: h.role, content: sanitizeText(h.content, 400) }));
 
-    // Add context from the request
+    const result = await classify({ message: cleanMessage, history, deps });
     result.context = context;
     result.timestamp = new Date().toISOString();
-
-    // For deploy intents with an appId, include the deploy plan
-    if (result.intent === 'deploy' && result.appId) {
-      result.deployPlan = {
-        templateId: result.appId,
-        endpoint: 'POST /api/v1/discover/adopt',
-        body: {
-          containerId: null, // Will be set after container creation
-          serviceId: result.appId,
-          name: result.appId.charAt(0).toUpperCase() + result.appId.slice(1),
-          port: null, // Will be set from template
-          generateDns: true,
-          generateRoute: true,
-        },
-        nextSteps: [
-          `Search catalog: GET /api/v1/catalog/search?q=${result.appId}`,
-          `Get template: GET /api/v1/catalog/${result.appId}`,
-          `Deploy: POST /api/v1/discover/adopt`,
-        ],
-      };
-    }
-
-    // For recommend intents, include the wizard endpoint
-    if (result.intent === 'recommend' && result.categories) {
-      result.wizardCall = {
-        endpoint: 'POST /api/v1/wizard/recommend',
-        body: { categories: result.categories, hardwareProfile: 'medium' },
-      };
-    }
+    enrich(result);
 
     ok(res, result);
   }));
 
   /**
-   * GET /api/v1/ai/capabilities
-   * Returns what the AI can do — useful for agent self-discovery
+   * GET /api/v1/ai/settings — LLM assistant configuration (key never echoed)
+   */
+  router.get('/ai/settings', wrap(async (req, res) => {
+    const cfg = await getLlmConfig(deps);
+    ok(res, {
+      configured: Boolean(cfg),
+      source: cfg ? cfg.source : null,
+      baseUrl: cfg ? cfg.baseUrl : null,
+      model: cfg ? cfg.model : null,
+      hasApiKey: Boolean(cfg && cfg.apiKey),
+    });
+  }));
+
+  /**
+   * PUT /api/v1/ai/settings — store LLM assistant config in the ENCRYPTED
+   * credential store (key 'ai:llm'). Never config.json — GET /config returns
+   * the raw file to the browser. body: { baseUrl?, model?, apiKey? }; an
+   * empty apiKey string means "keep the stored one".
+   */
+  router.put('/ai/settings', wrap(async (req, res) => {
+    if (!deps.credentialManager) {
+      return errorResponse(res, 503, 'Credential store unavailable — set AI_LLM_BASE_URL/AI_LLM_API_KEY env vars instead');
+    }
+    const { baseUrl = '', model = '', apiKey = '' } = req.body || {};
+    if (baseUrl && !/^https?:\/\//i.test(String(baseUrl).trim())) {
+      return errorResponse(res, 400, 'baseUrl must be an http(s) URL of an OpenAI-compatible endpoint');
+    }
+    let stored = null;
+    try {
+      const raw = await deps.credentialManager.retrieve('ai:llm');
+      if (raw) stored = typeof raw === 'string' ? JSON.parse(raw) : raw;
+    } catch (_) { /* fresh config */ }
+    stored = stored || {};
+    if (baseUrl) stored.baseUrl = String(baseUrl).trim();
+    if (model) stored.model = String(model).trim();
+    if (String(apiKey).trim()) stored.apiKey = String(apiKey).trim();
+    if (!stored.baseUrl || !stored.apiKey) {
+      return errorResponse(res, 400, 'baseUrl and apiKey are both required to enable the LLM engine (or clear with DELETE)');
+    }
+    await deps.credentialManager.store('ai:llm', JSON.stringify(stored), { label: 'AI assistant LLM config' });
+    log.info('ai-intent', 'LLM config saved', { model: stored.model });
+    ok(res, { saved: true, baseUrl: stored.baseUrl, model: stored.model, hasApiKey: true });
+  }));
+
+  /**
+   * DELETE /api/v1/ai/settings — remove stored config (falls back to env/pattern)
+   */
+  router.delete('/ai/settings', wrap(async (req, res) => {
+    if (!deps.credentialManager) return errorResponse(res, 503, 'Credential store unavailable');
+    try { await deps.credentialManager.delete('ai:llm'); } catch (_) { /* already gone */ }
+    ok(res, { cleared: true });
+  }));
+
+  /**
+   * POST /api/v1/ai/settings/test — one-shot classify probe proving the LLM
+   * works end-to-end (returns engine + sample intent, never the key).
+   */
+  router.post('/ai/settings/test', wrap(async (req, res) => {
+    const cfg = await getLlmConfig(deps);
+    if (!cfg) return ok(res, { ok: false, engine: 'pattern', reason: 'No LLM configured (store or env)' });
+    try {
+      const content = await callLlm(deps, cfg, [
+        { role: 'system', content: buildSystemPrompt() },
+        { role: 'user', content: 'Back up everything please' },
+      ]);
+      const parsed = JSON.parse(repairParsed(content));
+      const validated = validateParsed(parsed);
+      if (!validated || !validated.intent) throw new Error('invalid classifier output');
+      return ok(res, { ok: true, engine: 'llm', model: cfg.model, sample: { intent: validated.intent, reply: validated.reply } });
+    } catch (e) {
+      const reason = String((e && (e.name === 'AbortError' ? 'timeout' : e.message)) || 'error').slice(0, 200);
+      log.warn('ai-intent', 'LLM config test failed', { reason });
+      return ok(res, { ok: false, engine: 'llm-error', reason });
+    }
+  }));
+
+  /**
+   * GET /api/v1/ai/capabilities — what the AI can do + which engine is live
    */
   router.get('/ai/capabilities', wrap(async (req, res) => {
+    const cfg = await getLlmConfig(deps);
     ok(res, {
-      intents: [...new Set(INTENT_PATTERNS.map(p => p.intent))],
+      intents: INTENTS.filter((i) => i !== 'unknown'),
       capabilities: [
-        { name: 'deploy', description: 'Deploy self-hosted applications from the catalog' },
+        { name: 'deploy', description: 'Deploy self-hosted applications from the catalog (all 78 templates)' },
         { name: 'recommend', description: 'Get service recommendations based on goals' },
         { name: 'diagnose', description: 'Troubleshoot service issues' },
         { name: 'backup', description: 'Create full system backups' },
         { name: 'health', description: 'Check system and service health' },
         { name: 'list', description: 'List services and containers' },
       ],
-      tools: '17 MCP tools available via MCP protocol at src/mcp/mcp-server.js',
+      tools: '17 MCP tools available via MCP protocol at /api/v1/mcp',
+      engine: cfg ? 'llm' : 'pattern',
+      llm: cfg ? { model: cfg.model, configured: true, source: cfg.source } : { configured: false, howToEnable: 'Dashboard → AI Assistant panel → ⚙ Settings (stored in the encrypted credential store), or env AI_LLM_BASE_URL + AI_LLM_API_KEY + AI_LLM_MODEL' },
       exampleQueries: [
         'Deploy Plex',
-        'I want to stream movies',
+        'I want a private YouTube for my TV',
         'Block ads on my network',
         'Why is Plex down?',
         'Back up everything',
@@ -337,4 +685,16 @@ module.exports = function({ asyncHandler }) {
   return router;
 };
 
-module.exports.routeIntent = routeIntent;
\ No newline at end of file
+// ─── Pure exports (unit-test surface) ───────────────────────────────────────
+module.exports.routeIntent = routeIntent;
+module.exports.classify = classify;
+module.exports.enrich = enrich;
+module.exports.mergeIntent = mergeIntent;
+module.exports.validateParsed = validateParsed;
+module.exports.repairParsed = repairParsed;
+module.exports.buildSystemPrompt = buildSystemPrompt;
+module.exports.sanitizeText = sanitizeText;
+module.exports.resolveLlmConfig = resolveLlmConfig;
+module.exports.INTENTS = INTENTS;
+module.exports.TEMPLATE_IDS = TEMPLATE_IDS;
+module.exports.MAX_INPUT = MAX_INPUT;
diff --git a/dashcaddy-api/src/app.js b/dashcaddy-api/src/app.js
index 633fc25..d66f110 100644
--- a/dashcaddy-api/src/app.js
+++ b/dashcaddy-api/src/app.js
@@ -1022,7 +1022,7 @@ async function createApp() {
 
   // Log Insights — plain English activity summary + safe log disposal
   apiRouter.use('/disk-settings', diskSettingsRoutes);
-  apiRouter.use(aiIntentRoutes({ asyncHandler: ctx.asyncHandler }));
+  apiRouter.use(aiIntentRoutes({ asyncHandler: ctx.asyncHandler, siteConfig: ctx.siteConfig, log: ctx.log, credentialManager: ctx.credentialManager }));
   apiRouter.use(logInsightsRoutes({
     asyncHandler: ctx.asyncHandler,
     ok: ctx.ok,
diff --git a/status/dist/features.js b/status/dist/features.js
index 1ab7740..ca9c654 100644
--- a/status/dist/features.js
+++ b/status/dist/features.js
@@ -90,15 +90,15 @@
         <button id="logo-save" class="btn-accent">Save</button>
       </div>
     </div>
-  </div>`);const x=document.getElementById("logo-modal"),E=document.getElementById("logo-preview-dark"),R=document.getElementById("logo-preview-light"),h=document.getElementById("logo-status"),P=document.getElementById("logo-same-both"),A=document.getElementById("logo-dual-uploads"),D=document.getElementById("logo-single-upload"),j=document.getElementById("logo-upload-dark"),g=document.getElementById("logo-upload-light"),$=document.getElementById("logo-upload-single"),k=document.querySelector("#brand .brand-logo-dark"),M=document.querySelector("#brand .brand-logo-light"),T=document.querySelector(".top-row"),z=document.getElementById("dashboard-title"),C=DC.NAME;let H=null,b=null,d=null,v="left",S=C;P?.addEventListener("change",()=>{P.checked?(A.style.display="none",D.style.display="",H=null,b=null):(A.style.display="flex",D.style.display="none",d=null)});function O(t,e){if(!t||!t.type.startsWith("image/")){showNotification("Please select an image file","warning");return}const s=new FileReader;s.onload=n=>e(n.target.result),s.readAsDataURL(t)}j?.addEventListener("change",t=>{O(t.target.files[0],e=>{H=e,E.src=e,h.textContent="New dark logo ready to save"})}),g?.addEventListener("change",t=>{O(t.target.files[0],e=>{b=e,R.src=e,h.textContent="New light logo ready to save"})}),$?.addEventListener("change",t=>{O(t.target.files[0],e=>{d=e,E.src=e,R.src=e,h.textContent="New logo ready to save (both themes)"})});function m(t){T.setAttribute("data-logo-pos",t),document.querySelectorAll(".logo-pos-btn").forEach(e=>{e.style.background=e.dataset.pos===t?"var(--accent)":"var(--card-bg)",e.style.color=e.dataset.pos===t?"white":"var(--fg)"})}function f(t){S=t||C,document.title=S;const e=document.querySelector(".dashboard-title");e&&(e.textContent=S)}async function B(){try{const t=await fetch("/api/v1/logo");if(t.ok){const e=await t.json();e.customLogoDark&&(k.src=e.customLogoDark,E.src=e.customLogoDark),e.customLogoLight&&(M.src=e.customLogoLight,R.src=e.customLogoLight),!e.customLogoDark&&!e.customLogoLight&&e.customLogo&&(k.src=e.customLogo,M.src=e.customLogo,E.src=e.customLogo,R.src=e.customLogo),e.isDefault||(h.textContent="Using custom logo"),e.position&&(v=e.position,m(e.position)),e.dashboardTitle&&f(e.dashboardTitle)}}catch(t){console.warn("Could not load custom logo:",t.message)}}document.querySelectorAll(".logo-pos-btn").forEach(t=>{t.addEventListener("click",()=>{v=t.dataset.pos,m(v)})}),document.getElementById("brand")?.addEventListener("click",()=>{H=null,b=null,d=null,j&&(j.value=""),g&&(g.value=""),$&&($.value=""),P&&(P.checked=!1),A.style.display="flex",D.style.display="none",E.src=k.src,R.src=M.src;const t=k.src.includes("custom-logo")||M.src.includes("custom-logo");h.textContent=t?"Using custom logo":"Using default logos",m(v),z.value=S,x.classList.add("show")}),document.getElementById("logo-save")?.addEventListener("click",async()=>{try{const t=z.value.trim()||C,e={position:v,dashboardTitle:t};P?.checked&&d?(e.dataDark=d,e.dataLight=d):(H&&(e.dataDark=H),b&&(e.dataLight=b));const s=await secureFetch("/api/v1/logo",{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify(e)});if(s.ok){const n=await s.json(),r="?t="+Date.now();n.pathDark&&(k.src=n.pathDark+r,E.src=n.pathDark+r),n.pathLight&&(M.src=n.pathLight+r,R.src=n.pathLight+r),m(v),f(t),x.classList.remove("show")}else{const n=await s.json();showNotification("Failed to save: "+n.error,"error")}}catch(t){showNotification("Error saving: "+t.message,"error")}}),document.getElementById("logo-reset")?.addEventListener("click",async()=>{if(confirm(`Reset all branding to DashCaddy defaults?
+  </div>`);const x=document.getElementById("logo-modal"),E=document.getElementById("logo-preview-dark"),j=document.getElementById("logo-preview-light"),h=document.getElementById("logo-status"),P=document.getElementById("logo-same-both"),A=document.getElementById("logo-dual-uploads"),D=document.getElementById("logo-single-upload"),R=document.getElementById("logo-upload-dark"),y=document.getElementById("logo-upload-light"),$=document.getElementById("logo-upload-single"),k=document.querySelector("#brand .brand-logo-dark"),H=document.querySelector("#brand .brand-logo-light"),T=document.querySelector(".top-row"),z=document.getElementById("dashboard-title"),C=DC.NAME;let M=null,b=null,d=null,v="left",S=C;P?.addEventListener("change",()=>{P.checked?(A.style.display="none",D.style.display="",M=null,b=null):(A.style.display="flex",D.style.display="none",d=null)});function O(t,e){if(!t||!t.type.startsWith("image/")){showNotification("Please select an image file","warning");return}const s=new FileReader;s.onload=n=>e(n.target.result),s.readAsDataURL(t)}R?.addEventListener("change",t=>{O(t.target.files[0],e=>{M=e,E.src=e,h.textContent="New dark logo ready to save"})}),y?.addEventListener("change",t=>{O(t.target.files[0],e=>{b=e,j.src=e,h.textContent="New light logo ready to save"})}),$?.addEventListener("change",t=>{O(t.target.files[0],e=>{d=e,E.src=e,j.src=e,h.textContent="New logo ready to save (both themes)"})});function m(t){T.setAttribute("data-logo-pos",t),document.querySelectorAll(".logo-pos-btn").forEach(e=>{e.style.background=e.dataset.pos===t?"var(--accent)":"var(--card-bg)",e.style.color=e.dataset.pos===t?"white":"var(--fg)"})}function f(t){S=t||C,document.title=S;const e=document.querySelector(".dashboard-title");e&&(e.textContent=S)}async function B(){try{const t=await fetch("/api/v1/logo");if(t.ok){const e=await t.json();e.customLogoDark&&(k.src=e.customLogoDark,E.src=e.customLogoDark),e.customLogoLight&&(H.src=e.customLogoLight,j.src=e.customLogoLight),!e.customLogoDark&&!e.customLogoLight&&e.customLogo&&(k.src=e.customLogo,H.src=e.customLogo,E.src=e.customLogo,j.src=e.customLogo),e.isDefault||(h.textContent="Using custom logo"),e.position&&(v=e.position,m(e.position)),e.dashboardTitle&&f(e.dashboardTitle)}}catch(t){console.warn("Could not load custom logo:",t.message)}}document.querySelectorAll(".logo-pos-btn").forEach(t=>{t.addEventListener("click",()=>{v=t.dataset.pos,m(v)})}),document.getElementById("brand")?.addEventListener("click",()=>{M=null,b=null,d=null,R&&(R.value=""),y&&(y.value=""),$&&($.value=""),P&&(P.checked=!1),A.style.display="flex",D.style.display="none",E.src=k.src,j.src=H.src;const t=k.src.includes("custom-logo")||H.src.includes("custom-logo");h.textContent=t?"Using custom logo":"Using default logos",m(v),z.value=S,x.classList.add("show")}),document.getElementById("logo-save")?.addEventListener("click",async()=>{try{const t=z.value.trim()||C,e={position:v,dashboardTitle:t};P?.checked&&d?(e.dataDark=d,e.dataLight=d):(M&&(e.dataDark=M),b&&(e.dataLight=b));const s=await secureFetch("/api/v1/logo",{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify(e)});if(s.ok){const n=await s.json(),r="?t="+Date.now();n.pathDark&&(k.src=n.pathDark+r,E.src=n.pathDark+r),n.pathLight&&(H.src=n.pathLight+r,j.src=n.pathLight+r),m(v),f(t),x.classList.remove("show")}else{const n=await s.json();showNotification("Failed to save: "+n.error,"error")}}catch(t){showNotification("Error saving: "+t.message,"error")}}),document.getElementById("logo-reset")?.addEventListener("click",async()=>{if(confirm(`Reset all branding to DashCaddy defaults?
 
-This will reset the logo, favicon, title, and position.`))try{if((await secureFetch("/api/v1/logo",{method:"DELETE"})).ok&&(k.src="/assets/dashcaddy-logo-dark.png",M.src="/assets/dashcaddy-logo-light.png",E.src="/assets/dashcaddy-logo-dark.png",R.src="/assets/dashcaddy-logo-light.png",h.textContent="Using default logos",H=null,b=null,d=null,z.value=C,f(C),v="left",m("left")),(await secureFetch("/api/v1/favicon",{method:"DELETE"})).ok){const s=document.querySelector('link[rel="icon"]'),n=document.getElementById("favicon-preview"),r=document.getElementById("favicon-status");s&&(s.href="/assets/dashcaddy-favicon.ico?t="+Date.now()),n&&(n.src="/assets/dashcaddy-favicon.ico?t="+Date.now()),r&&(r.textContent="Using DashCaddy favicon"),l=null}}catch(t){showNotification("Error resetting branding: "+t.message,"error")}}),wireModal(x,document.getElementById("logo-cancel"));const w=document.getElementById("favicon-preview"),L=document.getElementById("favicon-status"),o=document.getElementById("favicon-upload"),p=document.querySelector('link[rel="icon"]')||document.createElement("link");let l=null;document.querySelector('link[rel="icon"]')||(p.rel="icon",p.href="/assets/dashcaddy-favicon.ico",document.head.appendChild(p));async function y(){try{const t=await fetch("/api/v1/favicon");if(t.ok){const e=await t.json();e.customFavicon&&(p.href=e.customFavicon+"?t="+Date.now(),w.src=e.customFavicon+"?t="+Date.now(),L.textContent="Using custom favicon")}}catch(t){console.warn("Could not load custom favicon:",t.message)}}o?.addEventListener("change",t=>{const e=t.target.files[0];if(!e)return;if(!e.type.match(/^image\/(png|svg\+xml)$/)){showNotification("Please select a PNG or SVG file","warning"),o.value="";return}const s=new FileReader;s.onload=n=>{l=n.target.result,w.src=l,L.textContent="New favicon ready to save"},s.readAsDataURL(e)}),document.getElementById("logo-save")?.addEventListener("click",async()=>{if(l)try{const t=await secureFetch("/api/v1/favicon",{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify({data:l})});if(t.ok){const e=await t.json();p.href=e.path+"?t="+Date.now(),w.src=e.path+"?t="+Date.now(),L.textContent="Using custom favicon",l=null}else{const e=await t.json();showNotification("Failed to save favicon: "+e.error,"error")}}catch(t){showNotification("Error saving favicon: "+t.message,"error")}}),y(),B();const u=document.getElementById("settings-timezone");u&&(new MutationObserver(()=>{x.classList.contains("show")&&u.options.length===0&&(async()=>{let e;try{const s=await fetch("/api/v1/config");s.ok&&(e=(await s.json()).timezone)}catch{}window.populateTimezoneSelect(u,e)})()}).observe(x,{attributes:!0,attributeFilter:["class"]}),document.getElementById("logo-save")?.addEventListener("click",async()=>{const e=u.value;if(e)try{const s=await fetch("/api/v1/config");if(!s.ok)return;const n=await s.json();n.timezone=e,n.updatedAt=new Date().toISOString(),await secureFetch("/api/v1/config",{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify(n)})}catch(s){console.warn("Failed to save timezone:",s.message)}}))})(),window.populateTimezoneSelect=function(x,E){const R=Intl.supportedValuesOf("timeZone"),h=E||Intl.DateTimeFormat().resolvedOptions().timeZone||"UTC";x.innerHTML="";for(const P of R){const A=document.createElement("option");A.value=P,A.textContent=P.replace(/_/g," "),P===h&&(A.selected=!0),x.appendChild(A)}},(function(){let x="homelab",E=null;async function R(){try{const f=await fetch("/api/v1/config");if(f.ok&&(E=await f.json(),E&&E.setupComplete))return document.getElementById("setup-wizard").style.display="none",!0}catch(f){console.warn("Could not fetch server config, checking localStorage fallback:",f.message)}return safeGet("dashcaddy-setup")?(document.getElementById("setup-wizard").style.display="none",!0):(document.getElementById("setup-wizard").style.display="flex",!1)}R();const h=document.getElementById("setup-timezone");h&&window.populateTimezoneSelect(h);function P(m){document.querySelectorAll(".setup-step").forEach(B=>{B.style.display="none"});const f=document.getElementById(m);f&&(f.style.display="block")}function A(){const m=document.getElementById("setup-summary-content");if(!m)return;let f='<div style="display: grid; gap: 20px;">';if(x==="homelab"){const w=document.getElementById("setup-tld")?.value?.trim()||".home",L=document.getElementById("setup-ca-name")?.value?.trim()||"",o=document.getElementById("setup-dns-ip")?.value?.trim()||"",p=document.getElementById("setup-dns-port")?.value?.trim()||DC.DEFAULTS.DNS_PORT;f+=`
+This will reset the logo, favicon, title, and position.`))try{if((await secureFetch("/api/v1/logo",{method:"DELETE"})).ok&&(k.src="/assets/dashcaddy-logo-dark.png",H.src="/assets/dashcaddy-logo-light.png",E.src="/assets/dashcaddy-logo-dark.png",j.src="/assets/dashcaddy-logo-light.png",h.textContent="Using default logos",M=null,b=null,d=null,z.value=C,f(C),v="left",m("left")),(await secureFetch("/api/v1/favicon",{method:"DELETE"})).ok){const s=document.querySelector('link[rel="icon"]'),n=document.getElementById("favicon-preview"),r=document.getElementById("favicon-status");s&&(s.href="/assets/dashcaddy-favicon.ico?t="+Date.now()),n&&(n.src="/assets/dashcaddy-favicon.ico?t="+Date.now()),r&&(r.textContent="Using DashCaddy favicon"),l=null}}catch(t){showNotification("Error resetting branding: "+t.message,"error")}}),wireModal(x,document.getElementById("logo-cancel"));const w=document.getElementById("favicon-preview"),L=document.getElementById("favicon-status"),o=document.getElementById("favicon-upload"),u=document.querySelector('link[rel="icon"]')||document.createElement("link");let l=null;document.querySelector('link[rel="icon"]')||(u.rel="icon",u.href="/assets/dashcaddy-favicon.ico",document.head.appendChild(u));async function g(){try{const t=await fetch("/api/v1/favicon");if(t.ok){const e=await t.json();e.customFavicon&&(u.href=e.customFavicon+"?t="+Date.now(),w.src=e.customFavicon+"?t="+Date.now(),L.textContent="Using custom favicon")}}catch(t){console.warn("Could not load custom favicon:",t.message)}}o?.addEventListener("change",t=>{const e=t.target.files[0];if(!e)return;if(!e.type.match(/^image\/(png|svg\+xml)$/)){showNotification("Please select a PNG or SVG file","warning"),o.value="";return}const s=new FileReader;s.onload=n=>{l=n.target.result,w.src=l,L.textContent="New favicon ready to save"},s.readAsDataURL(e)}),document.getElementById("logo-save")?.addEventListener("click",async()=>{if(l)try{const t=await secureFetch("/api/v1/favicon",{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify({data:l})});if(t.ok){const e=await t.json();u.href=e.path+"?t="+Date.now(),w.src=e.path+"?t="+Date.now(),L.textContent="Using custom favicon",l=null}else{const e=await t.json();showNotification("Failed to save favicon: "+e.error,"error")}}catch(t){showNotification("Error saving favicon: "+t.message,"error")}}),g(),B();const p=document.getElementById("settings-timezone");p&&(new MutationObserver(()=>{x.classList.contains("show")&&p.options.length===0&&(async()=>{let e;try{const s=await fetch("/api/v1/config");s.ok&&(e=(await s.json()).timezone)}catch{}window.populateTimezoneSelect(p,e)})()}).observe(x,{attributes:!0,attributeFilter:["class"]}),document.getElementById("logo-save")?.addEventListener("click",async()=>{const e=p.value;if(e)try{const s=await fetch("/api/v1/config");if(!s.ok)return;const n=await s.json();n.timezone=e,n.updatedAt=new Date().toISOString(),await secureFetch("/api/v1/config",{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify(n)})}catch(s){console.warn("Failed to save timezone:",s.message)}}))})(),window.populateTimezoneSelect=function(x,E){const j=Intl.supportedValuesOf("timeZone"),h=E||Intl.DateTimeFormat().resolvedOptions().timeZone||"UTC";x.innerHTML="";for(const P of j){const A=document.createElement("option");A.value=P,A.textContent=P.replace(/_/g," "),P===h&&(A.selected=!0),x.appendChild(A)}},(function(){let x="homelab",E=null;async function j(){try{const f=await fetch("/api/v1/config");if(f.ok&&(E=await f.json(),E&&E.setupComplete))return document.getElementById("setup-wizard").style.display="none",!0}catch(f){console.warn("Could not fetch server config, checking localStorage fallback:",f.message)}return safeGet("dashcaddy-setup")?(document.getElementById("setup-wizard").style.display="none",!0):(document.getElementById("setup-wizard").style.display="flex",!1)}j();const h=document.getElementById("setup-timezone");h&&window.populateTimezoneSelect(h);function P(m){document.querySelectorAll(".setup-step").forEach(B=>{B.style.display="none"});const f=document.getElementById(m);f&&(f.style.display="block")}function A(){const m=document.getElementById("setup-summary-content");if(!m)return;let f='<div style="display: grid; gap: 20px;">';if(x==="homelab"){const w=document.getElementById("setup-tld")?.value?.trim()||".home",L=document.getElementById("setup-ca-name")?.value?.trim()||"",o=document.getElementById("setup-dns-ip")?.value?.trim()||"",u=document.getElementById("setup-dns-port")?.value?.trim()||DC.DEFAULTS.DNS_PORT;f+=`
         <div>
           <h3 style="margin: 0 0 12px; color: var(--accent);">Home Lab Configuration</h3>
           <div style="display: grid; gap: 12px; font-size: 0.95rem;">
             <div><strong>TLD:</strong> ${w}</div>
             <div><strong>Certificate Authority:</strong> ${L}</div>
-            <div><strong>DNS Server:</strong> ${o}:${p}</div>
+            <div><strong>DNS Server:</strong> ${o}:${u}</div>
             <div><strong>Example URLs:</strong> https://uptime${w}, https://nextcloud${w}</div>
           </div>
         </div>
@@ -112,7 +112,7 @@ This will reset the logo, favicon, title, and position.`))try{if((await secureFe
             <div><strong>Example URLs:</strong> http://${w}:8080, http://${w}:3000</div>
           </div>
         </div>
-      `}else if(x==="public"){const w=document.getElementById("setup-public-domain")?.value?.trim()||"",L=document.getElementById("setup-public-email")?.value?.trim()||"",o=document.querySelector('input[name="routing-mode"]:checked')?.value||"subdirectory",p=o==="subdirectory"?`https://${w}/sonarr, https://${w}/grafana`:`https://sonarr.${w}, https://grafana.${w}`;f+=`
+      `}else if(x==="public"){const w=document.getElementById("setup-public-domain")?.value?.trim()||"",L=document.getElementById("setup-public-email")?.value?.trim()||"",o=document.querySelector('input[name="routing-mode"]:checked')?.value||"subdirectory",u=o==="subdirectory"?`https://${w}/sonarr, https://${w}/grafana`:`https://sonarr.${w}, https://grafana.${w}`;f+=`
         <div>
           <h3 style="margin: 0 0 12px; color: var(--accent);">Public Server</h3>
           <div style="display: grid; gap: 12px; font-size: 0.95rem;">
@@ -120,14 +120,14 @@ This will reset the logo, favicon, title, and position.`))try{if((await secureFe
             <div><strong>SSL:</strong> Let's Encrypt</div>
             <div><strong>Email:</strong> ${L}</div>
             <div><strong>Routing:</strong> ${o==="subdirectory"?"Subdirectory (domain.com/app)":"Subdomain (app.domain.com)"}</div>
-            <div><strong>Example URLs:</strong> ${p}</div>
+            <div><strong>Example URLs:</strong> ${u}</div>
           </div>
         </div>
       `}const B=document.getElementById("setup-timezone")?.value||Intl.DateTimeFormat().resolvedOptions().timeZone||"UTC";f+=`
       <div style="margin-top: 8px; padding-top: 12px; border-top: 1px solid var(--border);">
         <div style="font-size: 0.95rem;"><strong>Timezone:</strong> ${B.replace(/_/g," ")}</div>
       </div>
-    `,f+="</div>",m.innerHTML=f,P("setup-step-summary")}async function D(m){try{const f=await secureFetch("/api/v1/config",{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify(m)});return f.ok?(await f.json(),!0):(errorHandler.logError("[SetupWizard] Save Config",new Error(`Server returned ${f.status}`),{function:"saveConfigToServer"}),!1)}catch(f){return errorHandler.logError("[SetupWizard] Save Config",f,{function:"saveConfigToServer"}),!1}}async function j(){const m={setupComplete:!0,configurationType:x,timestamp:new Date().toISOString(),timezone:document.getElementById("setup-timezone")?.value||Intl.DateTimeFormat().resolvedOptions().timeZone||"UTC"};if(x==="homelab"){m.tld=document.getElementById("setup-tld")?.value?.trim()||".home",m.caName=document.getElementById("setup-ca-name")?.value?.trim()||"";const L=document.getElementById("setup-dns-provider")?.value||"technitium";m.dns={provider:L,ip:document.getElementById("setup-dns-ip")?.value?.trim()||"",port:document.getElementById("setup-dns-port")?.value?.trim()||DC.DEFAULTS.DNS_PORT,token:document.getElementById("setup-dns-token")?.value?.trim()||""},m.defaults={dnsType:"private",sslType:"internal",targetIP:"localhost"}}else x==="simple"?(m.defaultIP=document.getElementById("setup-simple-ip")?.value?.trim()||"localhost",m.defaults={dnsType:"none",sslType:"none",targetIP:m.defaultIP}):x==="public"&&(m.domain=document.getElementById("setup-public-domain")?.value?.trim()||"",m.email=document.getElementById("setup-public-email")?.value?.trim()||"",m.routingMode=document.querySelector('input[name="routing-mode"]:checked')?.value||"subdirectory",m.defaults={dnsType:m.routingMode==="subdirectory"?"none":"public",sslType:"letsencrypt",targetIP:"localhost"});const f=await D(m);safeSet("dashcaddy-config",JSON.stringify(m)),safeSet("dashcaddy-setup","completed"),document.getElementById("setup-wizard").style.display="none";const B=x==="homelab"?"Professional Home Lab":x==="simple"?"Simple Setup":"Public Server",w=f?"server (shared across all devices)":"locally (this browser only)";showNotification(`Setup Complete! Configured for: ${B}. Settings saved to: ${w}`,"success",5e3),setTimeout(()=>location.reload(),500)}const g=document.getElementById("setup-step-1-next");g&&(g.onclick=function(m){m.preventDefault();const f=document.querySelector('input[name="config-type"]:checked');f&&(x=f.value),P(x==="homelab"?"setup-step-homelab":x==="simple"?"setup-step-simple":x==="public"?"setup-step-public":"setup-step-homelab")});const $=document.getElementById("setup-skip");$&&($.onclick=async function(m){m.preventDefault(),confirm("Skip setup? You can run it later from Settings.")&&(await D({setupComplete:!0,skipped:!0,timestamp:new Date().toISOString()}),safeSet("dashcaddy-setup","skipped"),document.getElementById("setup-wizard").style.display="none")});const k=document.getElementById("setup-tld");k&&(k.oninput=function(m){const f=m.target.value||".home",B=document.getElementById("tld-preview"),w=document.getElementById("tld-preview-2");B&&(B.textContent=f),w&&(w.textContent=f)});const M=document.getElementById("setup-homelab-back");M&&(M.onclick=function(m){m.preventDefault(),P("setup-step-1")});const T=document.getElementById("setup-homelab-next");T&&(T.onclick=function(m){m.preventDefault();const f=document.getElementById("setup-tld")?.value?.trim()||"",B=document.getElementById("setup-ca-name")?.value?.trim()||"",w=document.getElementById("setup-dns-ip")?.value?.trim()||"";if(!f||!f.startsWith(".")){showNotification("Please enter a valid TLD starting with a dot (e.g., .home)","warning");return}if(!B){showNotification("Please enter a Certificate Authority name","warning");return}if(!w){showNotification("Please enter your DNS server IP address","warning");return}A()});const z=document.getElementById("setup-simple-back");z&&(z.onclick=function(m){m.preventDefault(),P("setup-step-1")});const C=document.getElementById("setup-simple-next");C&&(C.onclick=function(m){m.preventDefault(),A()}),document.querySelectorAll('input[name="routing-mode"]').forEach(function(m){m.onchange=function(){var f=document.getElementById("dns-requirement-note");f&&(f.textContent=this.value==="subdirectory"?"Only one DNS record needed (for the main domain)":"You'll need to configure DNS manually for each subdomain")}});const H=document.getElementById("setup-public-back");H&&(H.onclick=function(m){m.preventDefault(),P("setup-step-1")});const b=document.getElementById("setup-public-next");b&&(b.onclick=function(m){m.preventDefault();const f=document.getElementById("setup-public-domain")?.value?.trim()||"",B=document.getElementById("setup-public-email")?.value?.trim()||"";if(!f){showNotification("Please enter your domain name","warning");return}if(!B||!B.includes("@")){showNotification("Please enter a valid email address","warning");return}A()});const d=document.getElementById("setup-summary-back");d&&(d.onclick=function(m){m.preventDefault(),x==="homelab"?P("setup-step-homelab"):x==="simple"?P("setup-step-simple"):x==="public"&&P("setup-step-public")});const v=document.getElementById("setup-summary-next");v&&(v.onclick=function(m){m.preventDefault(),P("setup-step-disk-safety")});const S=document.getElementById("setup-disk-safety-back");S&&(S.onclick=function(m){m.preventDefault(),P("setup-step-summary")});const O=document.getElementById("setup-disk-safety-finish");O&&(O.onclick=function(m){m.preventDefault(),j()}),window.getGlobalConfig=async function(){try{const f=await fetch("/api/v1/config");if(f.ok){const B=await f.json();if(B&&B.setupComplete)return B}}catch{console.warn("Could not fetch config from server")}const m=safeGet("dashcaddy-config");return m?JSON.parse(m):{setupComplete:!1,configurationType:"homelab",tld:".home",caName:"",defaults:{dnsType:"private",sslType:"internal",targetIP:"localhost"}}},window.resetSetupWizard=async function(){if(confirm("Reset DashCaddy configuration? This will show the setup wizard again.")){try{await secureFetch("/api/v1/config",{method:"DELETE"})}catch{console.warn("Could not delete server config")}safeRemove("dashcaddy-setup"),safeRemove("dashcaddy-config"),location.reload()}}})(),(function(){const x=new ErrorHandler;injectModal("app-selector-modal",`<div id="app-selector-modal" class="weather-modal">
+    `,f+="</div>",m.innerHTML=f,P("setup-step-summary")}async function D(m){try{const f=await secureFetch("/api/v1/config",{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify(m)});return f.ok?(await f.json(),!0):(errorHandler.logError("[SetupWizard] Save Config",new Error(`Server returned ${f.status}`),{function:"saveConfigToServer"}),!1)}catch(f){return errorHandler.logError("[SetupWizard] Save Config",f,{function:"saveConfigToServer"}),!1}}async function R(){const m={setupComplete:!0,configurationType:x,timestamp:new Date().toISOString(),timezone:document.getElementById("setup-timezone")?.value||Intl.DateTimeFormat().resolvedOptions().timeZone||"UTC"};if(x==="homelab"){m.tld=document.getElementById("setup-tld")?.value?.trim()||".home",m.caName=document.getElementById("setup-ca-name")?.value?.trim()||"";const L=document.getElementById("setup-dns-provider")?.value||"technitium";m.dns={provider:L,ip:document.getElementById("setup-dns-ip")?.value?.trim()||"",port:document.getElementById("setup-dns-port")?.value?.trim()||DC.DEFAULTS.DNS_PORT,token:document.getElementById("setup-dns-token")?.value?.trim()||""},m.defaults={dnsType:"private",sslType:"internal",targetIP:"localhost"}}else x==="simple"?(m.defaultIP=document.getElementById("setup-simple-ip")?.value?.trim()||"localhost",m.defaults={dnsType:"none",sslType:"none",targetIP:m.defaultIP}):x==="public"&&(m.domain=document.getElementById("setup-public-domain")?.value?.trim()||"",m.email=document.getElementById("setup-public-email")?.value?.trim()||"",m.routingMode=document.querySelector('input[name="routing-mode"]:checked')?.value||"subdirectory",m.defaults={dnsType:m.routingMode==="subdirectory"?"none":"public",sslType:"letsencrypt",targetIP:"localhost"});const f=await D(m);safeSet("dashcaddy-config",JSON.stringify(m)),safeSet("dashcaddy-setup","completed"),document.getElementById("setup-wizard").style.display="none";const B=x==="homelab"?"Professional Home Lab":x==="simple"?"Simple Setup":"Public Server",w=f?"server (shared across all devices)":"locally (this browser only)";showNotification(`Setup Complete! Configured for: ${B}. Settings saved to: ${w}`,"success",5e3),setTimeout(()=>location.reload(),500)}const y=document.getElementById("setup-step-1-next");y&&(y.onclick=function(m){m.preventDefault();const f=document.querySelector('input[name="config-type"]:checked');f&&(x=f.value),P(x==="homelab"?"setup-step-homelab":x==="simple"?"setup-step-simple":x==="public"?"setup-step-public":"setup-step-homelab")});const $=document.getElementById("setup-skip");$&&($.onclick=async function(m){m.preventDefault(),confirm("Skip setup? You can run it later from Settings.")&&(await D({setupComplete:!0,skipped:!0,timestamp:new Date().toISOString()}),safeSet("dashcaddy-setup","skipped"),document.getElementById("setup-wizard").style.display="none")});const k=document.getElementById("setup-tld");k&&(k.oninput=function(m){const f=m.target.value||".home",B=document.getElementById("tld-preview"),w=document.getElementById("tld-preview-2");B&&(B.textContent=f),w&&(w.textContent=f)});const H=document.getElementById("setup-homelab-back");H&&(H.onclick=function(m){m.preventDefault(),P("setup-step-1")});const T=document.getElementById("setup-homelab-next");T&&(T.onclick=function(m){m.preventDefault();const f=document.getElementById("setup-tld")?.value?.trim()||"",B=document.getElementById("setup-ca-name")?.value?.trim()||"",w=document.getElementById("setup-dns-ip")?.value?.trim()||"";if(!f||!f.startsWith(".")){showNotification("Please enter a valid TLD starting with a dot (e.g., .home)","warning");return}if(!B){showNotification("Please enter a Certificate Authority name","warning");return}if(!w){showNotification("Please enter your DNS server IP address","warning");return}A()});const z=document.getElementById("setup-simple-back");z&&(z.onclick=function(m){m.preventDefault(),P("setup-step-1")});const C=document.getElementById("setup-simple-next");C&&(C.onclick=function(m){m.preventDefault(),A()}),document.querySelectorAll('input[name="routing-mode"]').forEach(function(m){m.onchange=function(){var f=document.getElementById("dns-requirement-note");f&&(f.textContent=this.value==="subdirectory"?"Only one DNS record needed (for the main domain)":"You'll need to configure DNS manually for each subdomain")}});const M=document.getElementById("setup-public-back");M&&(M.onclick=function(m){m.preventDefault(),P("setup-step-1")});const b=document.getElementById("setup-public-next");b&&(b.onclick=function(m){m.preventDefault();const f=document.getElementById("setup-public-domain")?.value?.trim()||"",B=document.getElementById("setup-public-email")?.value?.trim()||"";if(!f){showNotification("Please enter your domain name","warning");return}if(!B||!B.includes("@")){showNotification("Please enter a valid email address","warning");return}A()});const d=document.getElementById("setup-summary-back");d&&(d.onclick=function(m){m.preventDefault(),x==="homelab"?P("setup-step-homelab"):x==="simple"?P("setup-step-simple"):x==="public"&&P("setup-step-public")});const v=document.getElementById("setup-summary-next");v&&(v.onclick=function(m){m.preventDefault(),P("setup-step-disk-safety")});const S=document.getElementById("setup-disk-safety-back");S&&(S.onclick=function(m){m.preventDefault(),P("setup-step-summary")});const O=document.getElementById("setup-disk-safety-finish");O&&(O.onclick=function(m){m.preventDefault(),R()}),window.getGlobalConfig=async function(){try{const f=await fetch("/api/v1/config");if(f.ok){const B=await f.json();if(B&&B.setupComplete)return B}}catch{console.warn("Could not fetch config from server")}const m=safeGet("dashcaddy-config");return m?JSON.parse(m):{setupComplete:!1,configurationType:"homelab",tld:".home",caName:"",defaults:{dnsType:"private",sslType:"internal",targetIP:"localhost"}}},window.resetSetupWizard=async function(){if(confirm("Reset DashCaddy configuration? This will show the setup wizard again.")){try{await secureFetch("/api/v1/config",{method:"DELETE"})}catch{console.warn("Could not delete server config")}safeRemove("dashcaddy-setup"),safeRemove("dashcaddy-config"),location.reload()}}})(),(function(){const x=new ErrorHandler;injectModal("app-selector-modal",`<div id="app-selector-modal" class="weather-modal">
     <div class="app-selector-content">
       <h2 style="margin: 0 0 24px; color: var(--fg); text-align: center;">Choose an App</h2>
       <div id="app-selector-grid" class="app-selector-grid"></div>
@@ -333,12 +333,12 @@ This will reset the logo, favicon, title, and position.`))try{if((await secureFe
         </button>
       </div>
     </div>
-  </div>`);const E="custom-apps";let R=null,h=null;const P=document.getElementById("app-selector-modal"),A=document.getElementById("app-selector-grid");async function D(){try{const p=await(await fetch("/api/v1/apps/templates")).json();if(p.success)return R=p.templates,h=p.categories,!0}catch(o){x.logError("[AppSelector] Fetch Templates",o,{function:"fetchApiTemplates"})}return!1}async function j(o){try{return await(await fetch(`/api/v1/apps/ports/${o}/check`)).json()}catch(p){return x.logError("[AppSelector] Check Port",p,{function:"checkPortAvailability"}),{available:!0}}}async function g(o){try{const l=await(await fetch(`/api/v1/apps/ports/${o}/suggest`)).json();if(l.success)return l.suggestedPort}catch(p){x.logError("[AppSelector] Get Suggested Port",p,{function:"getSuggestedPort"})}return o}async function $(){if(A.innerHTML='<div style="text-align: center; padding: 40px; color: var(--muted);">Loading app templates...</div>',!R&&!await D()){A.innerHTML='<div style="text-align: center; padding: 40px; color: var(--error);">Failed to load app templates. Please try again.</div>';return}A.innerHTML="";const o={};for(const[l,y]of Object.entries(R)){const u=y.category||"Other";o[u]||(o[u]=[]),o[u].push({id:l,...y})}const p=h?Object.keys(h):Object.keys(o).sort();for(const l of p){const y=o[l];if(!y||y.length===0)continue;y.sort((e,s)=>(s.popularity||0)-(e.popularity||0));const u=document.createElement("div");u.className="app-category-header";const t=h?.[l]||{};u.innerHTML=`${escapeHtml(t.icon||"")} ${escapeHtml(l)}`,t.color&&(u.style.borderBottomColor=t.color),A.appendChild(u),y.forEach(e=>{const s=document.createElement("div");s.className="app-option";const n=e.isDashboardWidget,r=n&&safeGet("widget-"+e.id+"-enabled")!=="false",a=n?`<div style="font-size: 0.65rem; padding: 2px 6px; border-radius: 4px; margin-top: 4px; background: ${r?"#2ecc7130":"#e74c3c30"}; color: ${r?"#2ecc71":"#e74c3c"}; font-weight: 600;">${r?"ON":"OFF"}</div>`:"",i=!n&&e.difficulty?`<div style="font-size: 0.65rem; padding: 2px 6px; border-radius: 4px; margin-top: 4px; background: ${e.difficulty==="Easy"?"#2ecc71":e.difficulty==="Intermediate"?"#f39c12":"#e74c3c"}20; color: ${e.difficulty==="Easy"?"#2ecc71":e.difficulty==="Intermediate"?"#f39c12":"#e74c3c"};">${escapeHtml(e.difficulty)}</div>`:"";s.innerHTML=`
+  </div>`);const E="custom-apps";let j=null,h=null;const P=document.getElementById("app-selector-modal"),A=document.getElementById("app-selector-grid");async function D(){try{const u=await(await fetch("/api/v1/apps/templates")).json();if(u.success)return j=u.templates,h=u.categories,!0}catch(o){x.logError("[AppSelector] Fetch Templates",o,{function:"fetchApiTemplates"})}return!1}async function R(o){try{return await(await fetch(`/api/v1/apps/ports/${o}/check`)).json()}catch(u){return x.logError("[AppSelector] Check Port",u,{function:"checkPortAvailability"}),{available:!0}}}async function y(o){try{const l=await(await fetch(`/api/v1/apps/ports/${o}/suggest`)).json();if(l.success)return l.suggestedPort}catch(u){x.logError("[AppSelector] Get Suggested Port",u,{function:"getSuggestedPort"})}return o}async function $(){if(A.innerHTML='<div style="text-align: center; padding: 40px; color: var(--muted);">Loading app templates...</div>',!j&&!await D()){A.innerHTML='<div style="text-align: center; padding: 40px; color: var(--error);">Failed to load app templates. Please try again.</div>';return}A.innerHTML="";const o={};for(const[l,g]of Object.entries(j)){const p=g.category||"Other";o[p]||(o[p]=[]),o[p].push({id:l,...g})}const u=h?Object.keys(h):Object.keys(o).sort();for(const l of u){const g=o[l];if(!g||g.length===0)continue;g.sort((e,s)=>(s.popularity||0)-(e.popularity||0));const p=document.createElement("div");p.className="app-category-header";const t=h?.[l]||{};p.innerHTML=`${escapeHtml(t.icon||"")} ${escapeHtml(l)}`,t.color&&(p.style.borderBottomColor=t.color),A.appendChild(p),g.forEach(e=>{const s=document.createElement("div");s.className="app-option";const n=e.isDashboardWidget,r=n&&safeGet("widget-"+e.id+"-enabled")!=="false",a=n?`<div style="font-size: 0.65rem; padding: 2px 6px; border-radius: 4px; margin-top: 4px; background: ${r?"#2ecc7130":"#e74c3c30"}; color: ${r?"#2ecc71":"#e74c3c"}; font-weight: 600;">${r?"ON":"OFF"}</div>`:"",i=!n&&e.difficulty?`<div style="font-size: 0.65rem; padding: 2px 6px; border-radius: 4px; margin-top: 4px; background: ${e.difficulty==="Easy"?"#2ecc71":e.difficulty==="Intermediate"?"#f39c12":"#e74c3c"}20; color: ${e.difficulty==="Easy"?"#2ecc71":e.difficulty==="Intermediate"?"#f39c12":"#e74c3c"};">${escapeHtml(e.difficulty)}</div>`:"";s.innerHTML=`
           <div class="app-option-icon">${escapeHtml(e.icon||"\u{1F4E6}")}</div>
           <div class="app-option-name">${escapeHtml(e.name)}</div>
           <div class="app-option-desc">${escapeHtml(e.description||"")}</div>
           ${a}${i}
-        `,n?s.onclick=()=>k(e,s):s.onclick=()=>M(e),A.appendChild(s)})}window.renderRecipeCards&&await window.renderRecipeCards(A)}function k(o,p){const l="widget-"+o.id+"-enabled",u=!(safeGet(l)!=="false");safeSet(l,String(u));const t=o.widgetSelector;if(t){const s=document.querySelector(t);s&&(s.style.display=u?"":"none")}const e=p.querySelector('div[style*="border-radius: 4px"]');e&&(e.textContent=u?"ON":"OFF",e.style.background=u?"#2ecc7130":"#e74c3c30",e.style.color=u?"#2ecc71":"#e74c3c"),showNotification(`${o.name} widget ${u?"enabled":"disabled"}`,"success",2e3)}async function M(o){const p=document.getElementById("app-deploy-modal"),l=document.getElementById("app-deploy-title"),y=document.getElementById("deploy-subdomain"),u=document.getElementById("deploy-url-preview"),t=document.getElementById("deploy-ip"),e=document.getElementById("deploy-port"),s=document.getElementById("deploy-tailscale-only"),n=document.getElementById("tailscale-status");try{const G=await(await secureFetch("/api/v1/apps/check-existing",{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify({appId:o.id})})).json();if(G.success&&G.exists){const V=G.container;confirm(`Found existing ${o.name} container:
+        `,n?s.onclick=()=>k(e,s):s.onclick=()=>H(e),A.appendChild(s)})}window.renderRecipeCards&&await window.renderRecipeCards(A)}function k(o,u){const l="widget-"+o.id+"-enabled",p=!(safeGet(l)!=="false");safeSet(l,String(p));const t=o.widgetSelector;if(t){const s=document.querySelector(t);s&&(s.style.display=p?"":"none")}const e=u.querySelector('div[style*="border-radius: 4px"]');e&&(e.textContent=p?"ON":"OFF",e.style.background=p?"#2ecc7130":"#e74c3c30",e.style.color=p?"#2ecc71":"#e74c3c"),showNotification(`${o.name} widget ${p?"enabled":"disabled"}`,"success",2e3)}async function H(o){const u=document.getElementById("app-deploy-modal"),l=document.getElementById("app-deploy-title"),g=document.getElementById("deploy-subdomain"),p=document.getElementById("deploy-url-preview"),t=document.getElementById("deploy-ip"),e=document.getElementById("deploy-port"),s=document.getElementById("deploy-tailscale-only"),n=document.getElementById("tailscale-status");try{const G=await(await secureFetch("/api/v1/apps/check-existing",{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify({appId:o.id})})).json();if(G.success&&G.exists){const V=G.container;confirm(`Found existing ${o.name} container:
 
 Container: ${V.name}
 Status: ${V.status}
@@ -347,38 +347,38 @@ Port: ${V.primaryPort||"N/A"}
 Would you like to use this existing container?
 
 Click OK to configure DNS/Caddy for the existing container.
-Click Cancel to deploy a new container.`)&&(o._useExisting=!0,o._existingContainer=V)}}catch{}l.textContent=`Deploy ${o.name}`;const r=o.subdomain||o.id.replace(/-/g,"");y.value=r;const a=document.getElementById("subpath-compat-warning");if(a)if(SITE.routingMode==="subdirectory"){const W=o.subpathSupport||"strip";W==="none"?(a.style.display="block",a.innerHTML='<span style="color: #ff9800;">&#9888; <strong>'+o.name+"</strong> does not support subdirectory mode. It may not work correctly at a subpath.</span>"):W==="strip"?(a.style.display="block",a.innerHTML='<span style="color: var(--muted);">&#9432; '+o.name+" has unverified subdirectory support. It may require additional configuration.</span>"):a.style.display="none"}else a.style.display="none";const i=SITE.defaults.dnsType||(SITE.configurationType==="public"?"public":"private"),c=SITE.defaults.sslType||(SITE.configurationType==="public"?"letsencrypt":"internal"),I=document.querySelector(`input[name="dns-type"][value="${i}"]`),N=document.querySelector(`input[name="ssl-type"][value="${c}"]`);I?I.checked=!0:document.querySelector('input[name="dns-type"][value="private"]').checked=!0,N?N.checked=!0:document.querySelector('input[name="ssl-type"][value="internal"]').checked=!0,t.value=SITE.defaults.targetIP||"localhost",s.checked=!1;const U=document.querySelector("#app-deploy-modal .flex-col-gap")?.closest("div"),_=document.querySelector("#app-deploy-modal details"),F=_?.querySelector("div");if(_&&F&&(SITE.configurationType==="public"||SITE.configurationType==="homelab")){const W=document.querySelectorAll('#app-deploy-modal input[name="dns-type"]')[0]?.closest("div.flex-col-gap")?.parentElement,G=document.querySelectorAll('#app-deploy-modal input[name="ssl-type"]')[0]?.closest("div.flex-col-gap")?.parentElement;W&&!W.dataset.moved&&(F.appendChild(W),W.dataset.moved="1"),G&&!G.dataset.moved&&(F.appendChild(G),G.dataset.moved="1")}const q=document.getElementById("media-path-section"),J=document.getElementById("deploy-media-path"),X=document.getElementById("media-path-description");if(o.mediaMount){q.style.display="block",J.value="",J.placeholder="/media/Movies, /media/TVShows or click Browse";const W=document.getElementById("detected-mounts-container"),G=document.getElementById("detected-mounts-list");try{const K=await(await fetch("/api/v1/media/detected-mounts")).json();if(K.success&&K.mounts.length>0){W.style.display="block",G.innerHTML="";const te=[...new Set(K.mounts.map(ee=>ee.hostPath))];J.value=te.join(", "),K.mounts.forEach(ee=>{const Z=document.createElement("button");Z.type="button";const de=te.includes(ee.hostPath);Z.style.cssText=`padding: 8px 14px; font-size: 0.85rem; background: color-mix(in srgb, var(--success) ${de?"40%":"15%"}, var(--card-bg)); border: 1px solid var(--success); border-radius: 6px; cursor: pointer; color: var(--fg);`,Z.innerHTML=`<span style="font-weight: 500;">${escapeHtml(ee.folderName)}</span><br><span style="font-size: 0.7rem; color: var(--muted);">from ${escapeHtml(ee.sourceImage)}</span>`,Z.title=`${ee.hostPath} (from ${ee.sourceContainer})`,Z.onclick=()=>{const le=J.value.split(",").map(ce=>ce.trim()).filter(ce=>ce),pe=le.indexOf(ee.hostPath);pe>=0?(le.splice(pe,1),Z.style.background="color-mix(in srgb, var(--success) 15%, var(--card-bg))"):(le.push(ee.hostPath),Z.style.background="color-mix(in srgb, var(--success) 40%, var(--card-bg))"),J.value=le.join(", ")},G.appendChild(Z)})}else W.style.display="none"}catch{W.style.display="none"}document.getElementById("browse-media-btn").onclick=()=>{openFolderBrowser(J)}}else q.style.display="none",J.value="",document.getElementById("detected-mounts-container").style.display="none";const Q=document.getElementById("plex-claim-section");Q&&(o.id==="plex"||o.claimToken?(Q.style.display="block",document.getElementById("deploy-plex-claim").value=""):Q.style.display="none");const ne=document.getElementById("volume-mounts-section"),oe=document.getElementById("volume-mounts-list");if(oe.innerHTML="",o.docker?.volumes?.length){const W=o.mediaMount?.containerPath,G=o.docker.volumes.filter(V=>!V.includes("{{MEDIA_PATH}}")&&!(W&&V.endsWith(":"+W)));G.length>0?(ne.style.display="block",G.forEach((V,K)=>{const[te,ee]=V.split(":"),Z=document.createElement("div");Z.style.cssText="display: flex; gap: 6px; align-items: center;",Z.innerHTML=`
+Click Cancel to deploy a new container.`)&&(o._useExisting=!0,o._existingContainer=V)}}catch{}l.textContent=`Deploy ${o.name}`;const r=o.subdomain||o.id.replace(/-/g,"");g.value=r;const a=document.getElementById("subpath-compat-warning");if(a)if(SITE.routingMode==="subdirectory"){const W=o.subpathSupport||"strip";W==="none"?(a.style.display="block",a.innerHTML='<span style="color: #ff9800;">&#9888; <strong>'+o.name+"</strong> does not support subdirectory mode. It may not work correctly at a subpath.</span>"):W==="strip"?(a.style.display="block",a.innerHTML='<span style="color: var(--muted);">&#9432; '+o.name+" has unverified subdirectory support. It may require additional configuration.</span>"):a.style.display="none"}else a.style.display="none";const i=SITE.defaults.dnsType||(SITE.configurationType==="public"?"public":"private"),c=SITE.defaults.sslType||(SITE.configurationType==="public"?"letsencrypt":"internal"),I=document.querySelector(`input[name="dns-type"][value="${i}"]`),N=document.querySelector(`input[name="ssl-type"][value="${c}"]`);I?I.checked=!0:document.querySelector('input[name="dns-type"][value="private"]').checked=!0,N?N.checked=!0:document.querySelector('input[name="ssl-type"][value="internal"]').checked=!0,t.value=SITE.defaults.targetIP||"localhost",s.checked=!1;const U=document.querySelector("#app-deploy-modal .flex-col-gap")?.closest("div"),_=document.querySelector("#app-deploy-modal details"),F=_?.querySelector("div");if(_&&F&&(SITE.configurationType==="public"||SITE.configurationType==="homelab")){const W=document.querySelectorAll('#app-deploy-modal input[name="dns-type"]')[0]?.closest("div.flex-col-gap")?.parentElement,G=document.querySelectorAll('#app-deploy-modal input[name="ssl-type"]')[0]?.closest("div.flex-col-gap")?.parentElement;W&&!W.dataset.moved&&(F.appendChild(W),W.dataset.moved="1"),G&&!G.dataset.moved&&(F.appendChild(G),G.dataset.moved="1")}const q=document.getElementById("media-path-section"),J=document.getElementById("deploy-media-path"),X=document.getElementById("media-path-description");if(o.mediaMount){q.style.display="block",J.value="",J.placeholder="/media/Movies, /media/TVShows or click Browse";const W=document.getElementById("detected-mounts-container"),G=document.getElementById("detected-mounts-list");try{const K=await(await fetch("/api/v1/media/detected-mounts")).json();if(K.success&&K.mounts.length>0){W.style.display="block",G.innerHTML="";const te=[...new Set(K.mounts.map(ee=>ee.hostPath))];J.value=te.join(", "),K.mounts.forEach(ee=>{const Z=document.createElement("button");Z.type="button";const de=te.includes(ee.hostPath);Z.style.cssText=`padding: 8px 14px; font-size: 0.85rem; background: color-mix(in srgb, var(--success) ${de?"40%":"15%"}, var(--card-bg)); border: 1px solid var(--success); border-radius: 6px; cursor: pointer; color: var(--fg);`,Z.innerHTML=`<span style="font-weight: 500;">${escapeHtml(ee.folderName)}</span><br><span style="font-size: 0.7rem; color: var(--muted);">from ${escapeHtml(ee.sourceImage)}</span>`,Z.title=`${ee.hostPath} (from ${ee.sourceContainer})`,Z.onclick=()=>{const le=J.value.split(",").map(ce=>ce.trim()).filter(ce=>ce),pe=le.indexOf(ee.hostPath);pe>=0?(le.splice(pe,1),Z.style.background="color-mix(in srgb, var(--success) 15%, var(--card-bg))"):(le.push(ee.hostPath),Z.style.background="color-mix(in srgb, var(--success) 40%, var(--card-bg))"),J.value=le.join(", ")},G.appendChild(Z)})}else W.style.display="none"}catch{W.style.display="none"}document.getElementById("browse-media-btn").onclick=()=>{openFolderBrowser(J)}}else q.style.display="none",J.value="",document.getElementById("detected-mounts-container").style.display="none";const Q=document.getElementById("plex-claim-section");Q&&(o.id==="plex"||o.claimToken?(Q.style.display="block",document.getElementById("deploy-plex-claim").value=""):Q.style.display="none");const ne=document.getElementById("volume-mounts-section"),oe=document.getElementById("volume-mounts-list");if(oe.innerHTML="",o.docker?.volumes?.length){const W=o.mediaMount?.containerPath,G=o.docker.volumes.filter(V=>!V.includes("{{MEDIA_PATH}}")&&!(W&&V.endsWith(":"+W)));G.length>0?(ne.style.display="block",G.forEach((V,K)=>{const[te,ee]=V.split(":"),Z=document.createElement("div");Z.style.cssText="display: flex; gap: 6px; align-items: center;",Z.innerHTML=`
             <input type="text" class="vol-host-path" data-container-path="${ee}" value="${te}"
                    style="flex: 1; padding: 8px; background: var(--card-bg); color: var(--fg); border: 1px solid var(--border); border-radius: 6px; font-size: 0.85rem;" />
             <span style="color: var(--muted); font-size: 0.85rem; white-space: nowrap;">\u2192 ${ee}</span>
             <button type="button" class="vol-browse-btn" style="padding: 8px 10px; background: var(--accent); color: white; border: none; border-radius: 6px; cursor: pointer; font-size: 0.8rem;">\u{1F4C2}</button>
-          `,oe.appendChild(Z),Z.querySelector(".vol-browse-btn").onclick=()=>{const de=Z.querySelector(".vol-host-path");openFolderBrowser(de)}})):ne.style.display="none"}else ne.style.display="none";const se=o.defaultPort||8080;e.value="",e.placeholder=`Default: ${se}`;let Y=document.getElementById("deploy-port-status");Y||(Y=document.createElement("div"),Y.id="deploy-port-status",Y.style.cssText="font-size: 0.8rem; margin-top: 4px;",e.parentNode.appendChild(Y));async function ie(){const W=e.value||se;Y.innerHTML='<span style="color: var(--muted);">Checking port...</span>';const G=await j(W);if(G.available)Y.innerHTML=`<span style="color: #4caf50;">Port ${escapeHtml(String(W))} is available</span>`;else{const V=await g(se);Y.innerHTML=`
+          `,oe.appendChild(Z),Z.querySelector(".vol-browse-btn").onclick=()=>{const de=Z.querySelector(".vol-host-path");openFolderBrowser(de)}})):ne.style.display="none"}else ne.style.display="none";const se=o.defaultPort||8080;e.value="",e.placeholder=`Default: ${se}`;let Y=document.getElementById("deploy-port-status");Y||(Y=document.createElement("div"),Y.id="deploy-port-status",Y.style.cssText="font-size: 0.8rem; margin-top: 4px;",e.parentNode.appendChild(Y));async function ie(){const W=e.value||se;Y.innerHTML='<span style="color: var(--muted);">Checking port...</span>';const G=await R(W);if(G.available)Y.innerHTML=`<span style="color: #4caf50;">Port ${escapeHtml(String(W))} is available</span>`;else{const V=await y(se);Y.innerHTML=`
           <span style="color: #e74c3c;">Port ${escapeHtml(W)} in use by ${escapeHtml(G.conflict?.usedBy||"unknown")}</span>
         `;const K=document.createElement("button");K.type="button",K.textContent=`Use ${V}`,K.style.cssText="margin-left: 8px; padding: 2px 8px; font-size: 0.75rem; cursor: pointer;",K.onclick=()=>{document.getElementById("deploy-port").value=V,Y.innerHTML=`<span style="color: #4caf50;">Using suggested port ${escapeHtml(String(V))}</span>`},Y.appendChild(K)}}let re;e.oninput=function(){clearTimeout(re),re=setTimeout(ie,500)},ie();try{const G=await(await fetch("/api/v1/tailscale/status")).json();G.success&&G.installed&&G.connected?n.innerHTML=`
           <span style="color: #4caf50;">Connected</span>
           <span style="color: var(--muted); margin-left: 8px;">${G.self?.hostname} (${G.self?.ip})</span>
           <span style="color: var(--muted); margin-left: 8px;">| ${G.deviceCount} devices</span>
-        `:G.installed?n.innerHTML='<span style="color: #ff9800;">Not connected</span>':(n.innerHTML='<span style="color: var(--muted);">Not available</span>',s.disabled=!0)}catch{n.innerHTML='<span style="color: var(--muted);">Could not check status</span>'}function ae(){const W=y.value||"subdomain",G=document.querySelector('input[name="dns-type"]:checked').value,V=document.querySelector('input[name="ssl-type"]:checked').value;let K="";if(SITE.routingMode==="subdirectory"&&SITE.domain)K=`https://${SITE.domain}/${W}`;else if(G==="private")K=`${V==="none"?"http":"https"}://${buildDomain(W)}`;else if(G==="public"){const te=V==="none"?"http":"https",ee=SITE.domain||W;K=SITE.domain?`${te}://${W}.${SITE.domain}`:`${te}://${W}`}else{const te=e.value||o.defaultPort||DC.DEFAULTS.SERVICE_PORT;K=`http://${t.value}:${te}`}u.textContent=K}y.oninput=ae,t.oninput=ae,e.oninput=ae,document.querySelectorAll('input[name="dns-type"]').forEach(W=>{W.onchange=ae}),document.querySelectorAll('input[name="ssl-type"]').forEach(W=>{W.onchange=ae}),ae(),P.classList.remove("show"),p.classList.add("show"),p.dataset.appTemplate=JSON.stringify(o)}async function T(o){const p=o.appTemplate,l=safeGetJSON(E,[]),y=p._useExisting&&p._existingContainer,u=l.find(t=>t.id===o.subdomain);if(!(u&&!y&&!confirm(`An app with subdomain "${o.subdomain}" already exists. Redeploy?`))){if(u){const t=l.indexOf(u);l.splice(t,1),safeSet(E,JSON.stringify(l))}if(y)o.port=p._existingContainer.primaryPort;else{const t=o.port||p.defaultPort||8080;showNotification(`Checking port ${t} availability...`,"info",0);const e=await j(t);if(!e.available){const s=await g(p.defaultPort||8080);if(confirm(`Port ${t} is already in use by ${e.conflict?.usedBy||"another container"}.
+        `:G.installed?n.innerHTML='<span style="color: #ff9800;">Not connected</span>':(n.innerHTML='<span style="color: var(--muted);">Not available</span>',s.disabled=!0)}catch{n.innerHTML='<span style="color: var(--muted);">Could not check status</span>'}function ae(){const W=g.value||"subdomain",G=document.querySelector('input[name="dns-type"]:checked').value,V=document.querySelector('input[name="ssl-type"]:checked').value;let K="";if(SITE.routingMode==="subdirectory"&&SITE.domain)K=`https://${SITE.domain}/${W}`;else if(G==="private")K=`${V==="none"?"http":"https"}://${buildDomain(W)}`;else if(G==="public"){const te=V==="none"?"http":"https",ee=SITE.domain||W;K=SITE.domain?`${te}://${W}.${SITE.domain}`:`${te}://${W}`}else{const te=e.value||o.defaultPort||DC.DEFAULTS.SERVICE_PORT;K=`http://${t.value}:${te}`}p.textContent=K}g.oninput=ae,t.oninput=ae,e.oninput=ae,document.querySelectorAll('input[name="dns-type"]').forEach(W=>{W.onchange=ae}),document.querySelectorAll('input[name="ssl-type"]').forEach(W=>{W.onchange=ae}),ae(),P.classList.remove("show"),u.classList.add("show"),u.dataset.appTemplate=JSON.stringify(o)}async function T(o){const u=o.appTemplate,l=safeGetJSON(E,[]),g=u._useExisting&&u._existingContainer,p=l.find(t=>t.id===o.subdomain);if(!(p&&!g&&!confirm(`An app with subdomain "${o.subdomain}" already exists. Redeploy?`))){if(p){const t=l.indexOf(p);l.splice(t,1),safeSet(E,JSON.stringify(l))}if(g)o.port=u._existingContainer.primaryPort;else{const t=o.port||u.defaultPort||8080;showNotification(`Checking port ${t} availability...`,"info",0);const e=await R(t);if(!e.available){const s=await y(u.defaultPort||8080);if(confirm(`Port ${t} is already in use by ${e.conflict?.usedBy||"another container"}.
 
-Would you like to use port ${s} instead?`))o.port=s;else{showNotification("Deployment cancelled - port conflict","error",5e3);return}}}showNotification(y?`Configuring ${p.name} with existing container...`:`Deploying ${p.name}...`,"info",0);try{const t={appId:p.id,config:{subdomain:o.subdomain,ip:o.ip,createDns:o.dnsType==="private",port:o.port||p.defaultPort||null,sslType:o.sslType,dnsType:o.dnsType,tailscaleOnly:o.tailscaleOnly||!1,mediaPath:o.mediaPath||null,plexClaimToken:o.plexClaimToken||null,customVolumes:o.customVolumes||null}};y&&(t.config.useExisting=!0,t.config.existingContainerId=p._existingContainer.id,t.config.existingPort=p._existingContainer.primaryPort,!o.port&&p._existingContainer.primaryPort&&(t.config.port=p._existingContainer.primaryPort));const e={app:p.id,port:o.port||p.defaultPort||null,subdomain:o.subdomain||"",media_path:o.mediaPath||"",env:o.plexClaimToken?{PLEX_CLAIM:o.plexClaimToken}:{}},n=await(await secureFetch("/api/v1/deploys/catalog/deploy",{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify(e)})).json();if(n.success){const r={id:o.subdomain,name:p.name,logo:`/assets/${p.id}.png`,containerId:null,url:n.url||`http://127.0.0.1:${e.port}`,ip:o.ip,appTemplate:p.id,tailscaleOnly:o.tailscaleOnly||!1};l.push(r),safeSet(E,JSON.stringify(l)),window.APPS&&!window.APPS.some(i=>i.id===p.id)&&(window.APPS.push(r),typeof window.buildGrid=="function"&&window.buildGrid(),typeof window.refreshAll=="function"&&setTimeout(()=>window.refreshAll(),500));let a=n.usedExisting?`${p.name} configured with existing container!
-URL: ${n.url}`:`${p.name} deployed successfully!
+Would you like to use port ${s} instead?`))o.port=s;else{showNotification("Deployment cancelled - port conflict","error",5e3);return}}}showNotification(g?`Configuring ${u.name} with existing container...`:`Deploying ${u.name}...`,"info",0);try{const t={appId:u.id,config:{subdomain:o.subdomain,ip:o.ip,createDns:o.dnsType==="private",port:o.port||u.defaultPort||null,sslType:o.sslType,dnsType:o.dnsType,tailscaleOnly:o.tailscaleOnly||!1,mediaPath:o.mediaPath||null,plexClaimToken:o.plexClaimToken||null,customVolumes:o.customVolumes||null}};g&&(t.config.useExisting=!0,t.config.existingContainerId=u._existingContainer.id,t.config.existingPort=u._existingContainer.primaryPort,!o.port&&u._existingContainer.primaryPort&&(t.config.port=u._existingContainer.primaryPort));const e={app:u.id,port:o.port||u.defaultPort||null,subdomain:o.subdomain||"",media_path:o.mediaPath||"",env:o.plexClaimToken?{PLEX_CLAIM:o.plexClaimToken}:{}},n=await(await secureFetch("/api/v1/deploys/catalog/deploy",{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify(e)})).json();if(n.success){const r={id:o.subdomain,name:u.name,logo:`/assets/${u.id}.png`,containerId:null,url:n.url||`http://127.0.0.1:${e.port}`,ip:o.ip,appTemplate:u.id,tailscaleOnly:o.tailscaleOnly||!1};l.push(r),safeSet(E,JSON.stringify(l)),window.APPS&&!window.APPS.some(i=>i.id===u.id)&&(window.APPS.push(r),typeof window.buildGrid=="function"&&window.buildGrid(),typeof window.refreshAll=="function"&&setTimeout(()=>window.refreshAll(),500));let a=n.usedExisting?`${u.name} configured with existing container!
+URL: ${n.url}`:`${u.name} deployed successfully!
 URL: ${n.url}`;n.warning&&(a+=`
 
-\u26A0 Warning: ${n.warning}`),showNotification(a,"success",8e3),delete p._useExisting,delete p._existingContainer,n.url&&n.url.startsWith("https://")&&z(n.url,p.name),n.setupInstructions&&n.setupInstructions.length>0&&setTimeout(()=>{const i=n.setupInstructions.join(`
-`);showNotification(`Setup Instructions for ${p.name}: ${i}`,"info",1e4)},1e3)}else throw new Error(n.error||"Deployment failed")}catch(t){x.logError("[AppSelector] Deployment",t,{function:"deploy"}),showNotification(`Failed to deploy ${p.name}: ${t.message}`,"error",8e3)}}}async function z(o,p){showNotification(`\u23F3 Generating SSL certificate for ${p}...`,"warning",6e4);let l=0;const y=12,u=async()=>{l++;try{const t=await fetch(o,{method:"HEAD",mode:"no-cors"});return showNotification(`\u2705 ${p} is ready! SSL certificate generated.`,"success",5e3),!0}catch{return l<y?setTimeout(u,5e3):showNotification(`\u26A0\uFE0F ${p} deployed but SSL certificate may still be generating.
-Try refreshing in a moment if you see a certificate error.`,"warning",1e4),!1}};setTimeout(u,3e3)}function C(){safeGetJSON(E,[]).forEach(p=>{window.APPS.some(l=>l.id===p.id)||window.APPS.push(p)})}document.getElementById("add-service-btn")?.addEventListener("click",()=>{$(),P.classList.add("show")}),wireModal(P,document.getElementById("app-selector-cancel"));const H=document.getElementById("app-deploy-modal");document.getElementById("app-deploy-cancel")?.addEventListener("click",()=>{H.classList.remove("show")}),document.getElementById("app-deploy-confirm")?.addEventListener("click",()=>{const o=JSON.parse(H.dataset.appTemplate),p=document.getElementById("deploy-media-path").value.trim(),l=[];document.querySelectorAll("#volume-mounts-list .vol-host-path").forEach(u=>{l.push({hostPath:u.value.trim(),containerPath:u.dataset.containerPath})});const y={appTemplate:o,subdomain:document.getElementById("deploy-subdomain").value.trim(),dnsType:document.querySelector('input[name="dns-type"]:checked').value,sslType:document.querySelector('input[name="ssl-type"]:checked').value,ip:document.getElementById("deploy-ip").value.trim(),port:document.getElementById("deploy-port").value.trim(),tailscaleOnly:document.getElementById("deploy-tailscale-only").checked,mediaPath:p||null,plexClaimToken:document.getElementById("deploy-plex-claim")?.value.trim()||null,customVolumes:l.length>0?l:null,resources:{cpus:parseFloat(document.getElementById("deploy-cpu-limit").value)||0,memory:parseFloat(document.getElementById("deploy-memory-limit").value)||0}};if(!y.subdomain){showNotification("Please enter a subdomain or domain name","warning");return}if(o.mediaMount?.required&&!p){showNotification("Please enter a media library path for this application","warning");return}H.classList.remove("show"),T(y)}),wireModal(H);const b=document.getElementById("folder-browser-modal"),d=document.getElementById("folder-browser-path"),v=document.getElementById("folder-browser-list"),S=document.getElementById("folder-browser-selected"),O=document.getElementById("folder-browser-selected-list");let m="",f=[],B=null;window.openFolderBrowser=function(o){B=o,f=o.value.split(",").map(p=>p.trim()).filter(p=>p),m="",L(),w(""),b.classList.add("show")};async function w(o){d.textContent=o||"Select a drive...",v.innerHTML='<div style="padding: 20px; text-align: center; color: var(--muted);">Loading...</div>';try{const l=await(await fetch(`/api/v1/browse/directories?path=${encodeURIComponent(o)}`)).json();if(!l.success){v.innerHTML=`<div style="padding: 20px; text-align: center; color: var(--error);">Error: ${escapeHtml(l.error)}</div>`;return}m=l.path||"",d.textContent=m||"Select a drive...";let y="";l.parent&&l.parent!==l.path&&(y+=`<div class="folder-item" data-path="${escapeHtml(l.parent)}" style="padding: 12px 16px; border-bottom: 1px solid var(--border); cursor: pointer; display: flex; align-items: center; gap: 10px;">
+\u26A0 Warning: ${n.warning}`),showNotification(a,"success",8e3),delete u._useExisting,delete u._existingContainer,n.url&&n.url.startsWith("https://")&&z(n.url,u.name),n.setupInstructions&&n.setupInstructions.length>0&&setTimeout(()=>{const i=n.setupInstructions.join(`
+`);showNotification(`Setup Instructions for ${u.name}: ${i}`,"info",1e4)},1e3)}else throw new Error(n.error||"Deployment failed")}catch(t){x.logError("[AppSelector] Deployment",t,{function:"deploy"}),showNotification(`Failed to deploy ${u.name}: ${t.message}`,"error",8e3)}}}async function z(o,u){showNotification(`\u23F3 Generating SSL certificate for ${u}...`,"warning",6e4);let l=0;const g=12,p=async()=>{l++;try{const t=await fetch(o,{method:"HEAD",mode:"no-cors"});return showNotification(`\u2705 ${u} is ready! SSL certificate generated.`,"success",5e3),!0}catch{return l<g?setTimeout(p,5e3):showNotification(`\u26A0\uFE0F ${u} deployed but SSL certificate may still be generating.
+Try refreshing in a moment if you see a certificate error.`,"warning",1e4),!1}};setTimeout(p,3e3)}function C(){safeGetJSON(E,[]).forEach(u=>{window.APPS.some(l=>l.id===u.id)||window.APPS.push(u)})}document.getElementById("add-service-btn")?.addEventListener("click",()=>{$(),P.classList.add("show")}),window.openDeployConfigFor=async function(o){if(!j&&!await D())return!1;const u=String(o||"").toLowerCase(),l=Object.entries(j).find(([p])=>p.toLowerCase()===u);if(!l)return!1;const g={id:l[0],...l[1]};return g.isDashboardWidget?(await $(),P.classList.add("show"),"selector"):(await H(g),!0)},wireModal(P,document.getElementById("app-selector-cancel"));const M=document.getElementById("app-deploy-modal");document.getElementById("app-deploy-cancel")?.addEventListener("click",()=>{M.classList.remove("show")}),document.getElementById("app-deploy-confirm")?.addEventListener("click",()=>{const o=JSON.parse(M.dataset.appTemplate),u=document.getElementById("deploy-media-path").value.trim(),l=[];document.querySelectorAll("#volume-mounts-list .vol-host-path").forEach(p=>{l.push({hostPath:p.value.trim(),containerPath:p.dataset.containerPath})});const g={appTemplate:o,subdomain:document.getElementById("deploy-subdomain").value.trim(),dnsType:document.querySelector('input[name="dns-type"]:checked').value,sslType:document.querySelector('input[name="ssl-type"]:checked').value,ip:document.getElementById("deploy-ip").value.trim(),port:document.getElementById("deploy-port").value.trim(),tailscaleOnly:document.getElementById("deploy-tailscale-only").checked,mediaPath:u||null,plexClaimToken:document.getElementById("deploy-plex-claim")?.value.trim()||null,customVolumes:l.length>0?l:null,resources:{cpus:parseFloat(document.getElementById("deploy-cpu-limit").value)||0,memory:parseFloat(document.getElementById("deploy-memory-limit").value)||0}};if(!g.subdomain){showNotification("Please enter a subdomain or domain name","warning");return}if(o.mediaMount?.required&&!u){showNotification("Please enter a media library path for this application","warning");return}M.classList.remove("show"),T(g)}),wireModal(M);const b=document.getElementById("folder-browser-modal"),d=document.getElementById("folder-browser-path"),v=document.getElementById("folder-browser-list"),S=document.getElementById("folder-browser-selected"),O=document.getElementById("folder-browser-selected-list");let m="",f=[],B=null;window.openFolderBrowser=function(o){B=o,f=o.value.split(",").map(u=>u.trim()).filter(u=>u),m="",L(),w(""),b.classList.add("show")};async function w(o){d.textContent=o||"Select a drive...",v.innerHTML='<div style="padding: 20px; text-align: center; color: var(--muted);">Loading...</div>';try{const l=await(await fetch(`/api/v1/browse/directories?path=${encodeURIComponent(o)}`)).json();if(!l.success){v.innerHTML=`<div style="padding: 20px; text-align: center; color: var(--error);">Error: ${escapeHtml(l.error)}</div>`;return}m=l.path||"",d.textContent=m||"Select a drive...";let g="";l.parent&&l.parent!==l.path&&(g+=`<div class="folder-item" data-path="${escapeHtml(l.parent)}" style="padding: 12px 16px; border-bottom: 1px solid var(--border); cursor: pointer; display: flex; align-items: center; gap: 10px;">
           <span style="font-size: 1.2rem;">\u2B06\uFE0F</span>
           <span style="color: var(--muted);">.. Parent Directory</span>
-        </div>`),l.items.length===0&&!l.parent?y+='<div style="padding: 20px; text-align: center; color: var(--muted);">No browseable drives configured. Check your docker-compose.yml volume mounts.</div>':l.items.length===0?y+='<div style="padding: 20px; text-align: center; color: var(--muted);">No subfolders found</div>':l.items.forEach(u=>{const t=u.type==="drive"?"\u{1F4BE}":"\u{1F4C1}",e=f.includes(u.path),s=e?"background: color-mix(in srgb, var(--success) 20%, transparent);":"";y+=`<div class="folder-item" data-path="${escapeHtml(u.path)}" style="padding: 12px 16px; border-bottom: 1px solid var(--border); cursor: pointer; display: flex; align-items: center; gap: 10px; ${s}">
+        </div>`),l.items.length===0&&!l.parent?g+='<div style="padding: 20px; text-align: center; color: var(--muted);">No browseable drives configured. Check your docker-compose.yml volume mounts.</div>':l.items.length===0?g+='<div style="padding: 20px; text-align: center; color: var(--muted);">No subfolders found</div>':l.items.forEach(p=>{const t=p.type==="drive"?"\u{1F4BE}":"\u{1F4C1}",e=f.includes(p.path),s=e?"background: color-mix(in srgb, var(--success) 20%, transparent);":"";g+=`<div class="folder-item" data-path="${escapeHtml(p.path)}" style="padding: 12px 16px; border-bottom: 1px solid var(--border); cursor: pointer; display: flex; align-items: center; gap: 10px; ${s}">
             <span style="font-size: 1.2rem;">${t}</span>
-            <span style="flex: 1;">${escapeHtml(u.name)}</span>
+            <span style="flex: 1;">${escapeHtml(p.name)}</span>
             ${e?'<span style="color: var(--success);">\u2713</span>':""}
-          </div>`}),v.innerHTML=y,v.querySelectorAll(".folder-item").forEach(u=>{u.addEventListener("click",()=>{w(u.dataset.path)}),u.addEventListener("mouseenter",()=>{u.style.background="var(--card-bg)"}),u.addEventListener("mouseleave",()=>{const t=f.includes(u.dataset.path);u.style.background=t?"color-mix(in srgb, var(--success) 20%, transparent)":""})})}catch(p){v.innerHTML=`<div style="padding: 20px; text-align: center; color: var(--error);">Failed to load: ${escapeHtml(p.message)}</div>`}}function L(){if(f.length===0){S.style.display="none";return}S.style.display="block",O.innerHTML=f.map(o=>`
+          </div>`}),v.innerHTML=g,v.querySelectorAll(".folder-item").forEach(p=>{p.addEventListener("click",()=>{w(p.dataset.path)}),p.addEventListener("mouseenter",()=>{p.style.background="var(--card-bg)"}),p.addEventListener("mouseleave",()=>{const t=f.includes(p.dataset.path);p.style.background=t?"color-mix(in srgb, var(--success) 20%, transparent)":""})})}catch(u){v.innerHTML=`<div style="padding: 20px; text-align: center; color: var(--error);">Failed to load: ${escapeHtml(u.message)}</div>`}}function L(){if(f.length===0){S.style.display="none";return}S.style.display="block",O.innerHTML=f.map(o=>`
       <span style="padding: 6px 12px; background: var(--card-bg); border: 1px solid var(--success); border-radius: 4px; display: flex; align-items: center; gap: 6px;">
         ${escapeHtml(o)}
         <button type="button" onclick="removeSelectedFolder('${escapeHtml(o)}')" style="background: none; border: none; cursor: pointer; color: var(--error); font-size: 1rem; padding: 0;">\xD7</button>
       </span>
-    `).join("")}window.removeSelectedFolder=function(o){f=f.filter(p=>p!==o),L(),w(m)},document.getElementById("folder-browser-select-current").addEventListener("click",()=>{m&&!f.includes(m)&&(f.push(m),L(),w(m))}),wireModal(b,document.getElementById("folder-browser-cancel")),document.getElementById("folder-browser-done").addEventListener("click",()=>{B&&(B.value=f.join(", ")),b.classList.remove("show")}),C()})(),(function(){injectModal("recipe-deploy-modal",`<div id="recipe-deploy-modal" class="weather-modal">
+    `).join("")}window.removeSelectedFolder=function(o){f=f.filter(u=>u!==o),L(),w(m)},document.getElementById("folder-browser-select-current").addEventListener("click",()=>{m&&!f.includes(m)&&(f.push(m),L(),w(m))}),wireModal(b,document.getElementById("folder-browser-cancel")),document.getElementById("folder-browser-done").addEventListener("click",()=>{B&&(B.value=f.join(", ")),b.classList.remove("show")}),C()})(),(function(){injectModal("recipe-deploy-modal",`<div id="recipe-deploy-modal" class="weather-modal">
     <div class="weather-modal-content" style="min-width: 620px; max-width: 740px;">
       <h3 id="recipe-deploy-title">Deploy Recipe</h3>
 
@@ -445,13 +445,13 @@ Try refreshing in a moment if you see a certificate error.`,"warning",1e4),!1}};
         <button id="recipe-next" class="btn-accent-solid">Next</button>
       </div>
     </div>
-  </div>`);let x=null,E=null,R=null,h=1,P=!1;const A=document.getElementById("recipe-deploy-modal"),D=document.getElementById("recipe-cancel"),j=document.getElementById("recipe-prev"),g=document.getElementById("recipe-next");wireModal(A,D);async function $(){try{const m=await fetch("/api/v1/recipes/templates"),f=await m.json();if(f.success)return x=f.templates,E=f.categories,!0;if(m.status===403)return P=!1,!1}catch(m){console.warn("Failed to fetch recipe templates:",m.message)}return!1}async function k(){try{P=(await(await fetch("/api/v1/license/feature/recipes")).json()).available}catch{P=!1}return P}window.renderRecipeCards=async function(m){await k();let f;if(P&&x?f=x:f=M(),!f||f.length===0)return;const B=document.createElement("div");B.className="app-category-header",B.innerHTML="\u{1F9EA} Recipes",B.style.borderBottomColor="#8e44ad",m.appendChild(B);const w=Array.isArray(f)?f:Object.values(f);w.sort((L,o)=>(o.popularity||0)-(L.popularity||0));for(const L of w){const o=document.createElement("div");o.className="app-option",o.style.position="relative";const p=`<div style="font-size: 0.65rem; padding: 2px 6px; border-radius: 4px; margin-top: 4px; background: rgba(142,68,173,0.2); color: #a855f7;">${L.componentCount||L.components?.length||"?"} apps</div>`,l=P?"":'<div style="position: absolute; top: 6px; right: 6px; font-size: 0.65rem; padding: 2px 8px; border-radius: 10px; background: rgba(241,196,15,0.2); color: #f1c40f; font-weight: 600;">PREMIUM</div>';o.innerHTML=`
+  </div>`);let x=null,E=null,j=null,h=1,P=!1;const A=document.getElementById("recipe-deploy-modal"),D=document.getElementById("recipe-cancel"),R=document.getElementById("recipe-prev"),y=document.getElementById("recipe-next");wireModal(A,D);async function $(){try{const m=await fetch("/api/v1/recipes/templates"),f=await m.json();if(f.success)return x=f.templates,E=f.categories,!0;if(m.status===403)return P=!1,!1}catch(m){console.warn("Failed to fetch recipe templates:",m.message)}return!1}async function k(){try{P=(await(await fetch("/api/v1/license/feature/recipes")).json()).available}catch{P=!1}return P}window.renderRecipeCards=async function(m){await k();let f;if(P&&x?f=x:f=H(),!f||f.length===0)return;const B=document.createElement("div");B.className="app-category-header",B.innerHTML="\u{1F9EA} Recipes",B.style.borderBottomColor="#8e44ad",m.appendChild(B);const w=Array.isArray(f)?f:Object.values(f);w.sort((L,o)=>(o.popularity||0)-(L.popularity||0));for(const L of w){const o=document.createElement("div");o.className="app-option",o.style.position="relative";const u=`<div style="font-size: 0.65rem; padding: 2px 6px; border-radius: 4px; margin-top: 4px; background: rgba(142,68,173,0.2); color: #a855f7;">${L.componentCount||L.components?.length||"?"} apps</div>`,l=P?"":'<div style="position: absolute; top: 6px; right: 6px; font-size: 0.65rem; padding: 2px 8px; border-radius: 10px; background: rgba(241,196,15,0.2); color: #f1c40f; font-weight: 600;">PREMIUM</div>';o.innerHTML=`
         ${l}
         <div class="app-option-icon">${escapeHtml(L.icon||"\u{1F9EA}")}</div>
         <div class="app-option-name">${escapeHtml(L.name)}</div>
         <div class="app-option-desc">${escapeHtml(L.description||"")}</div>
-        ${p}
-      `,o.onclick=()=>{if(!P){showNotification("Recipes require a DashCaddy Premium license. Click the License button to activate.","warning",5e3),window.openLicenseModal&&window.openLicenseModal();return}T(L)},m.appendChild(o)}};function M(){return[{id:"htpc-suite",name:"HTPC Suite",icon:"\u{1F3AC}",description:"Complete media automation: find, download, organize, and stream",componentCount:6,popularity:98},{id:"nextcloud-complete",name:"Nextcloud Complete",icon:"\u2601\uFE0F",description:"Full productivity suite: cloud storage, office editing, and collaboration",componentCount:4,popularity:90},{id:"smart-home",name:"Smart Home Hub",icon:"\u{1F3E0}",description:"Home automation: control, automate, and monitor IoT devices",componentCount:4,popularity:88},{id:"dev-environment",name:"Dev Environment",icon:"\u{1F4BB}",description:"Self-hosted development workflow: Git, CI/CD, IDE, and database",componentCount:4,popularity:82}]}function T(m){R=m,h=1;const f=document.getElementById("app-selector-modal");f&&f.classList.remove("show"),document.getElementById("recipe-deploy-title").textContent=`Deploy ${m.name}`,z(),C(),A.classList.add("show")}function z(){document.querySelectorAll("#recipe-steps .recipe-step").forEach(m=>{const f=parseInt(m.dataset.step);m.classList.toggle("active",f===h),m.classList.toggle("completed",f<h)});for(let m=1;m<=4;m++){const f=document.getElementById(`recipe-step-${m}`);f&&(f.style.display=m===h?"":"none")}j.style.display=h>1&&h<4?"":"none",h===4?(g.style.display="none",D.textContent="Close"):h===3?(g.textContent="\u{1F680} Deploy",g.style.display="",D.textContent="Cancel"):(g.textContent="Next",g.style.display="",D.textContent="Cancel")}function C(){const m=document.getElementById("recipe-component-list");m.innerHTML="";const f=R.components||[];for(const B of f){const w=document.createElement("div");w.style.cssText="display: flex; align-items: center; gap: 12px; padding: 12px; border-radius: 8px; background: var(--card-bg); border: 1px solid var(--border);";const L=B.required,o=B.internal;w.innerHTML=`
+        ${u}
+      `,o.onclick=()=>{if(!P){showNotification("Recipes require a DashCaddy Premium license. Click the License button to activate.","warning",5e3),window.openLicenseModal&&window.openLicenseModal();return}T(L)},m.appendChild(o)}};function H(){return[{id:"htpc-suite",name:"HTPC Suite",icon:"\u{1F3AC}",description:"Complete media automation: find, download, organize, and stream",componentCount:6,popularity:98},{id:"nextcloud-complete",name:"Nextcloud Complete",icon:"\u2601\uFE0F",description:"Full productivity suite: cloud storage, office editing, and collaboration",componentCount:4,popularity:90},{id:"smart-home",name:"Smart Home Hub",icon:"\u{1F3E0}",description:"Home automation: control, automate, and monitor IoT devices",componentCount:4,popularity:88},{id:"dev-environment",name:"Dev Environment",icon:"\u{1F4BB}",description:"Self-hosted development workflow: Git, CI/CD, IDE, and database",componentCount:4,popularity:82}]}function T(m){j=m,h=1;const f=document.getElementById("app-selector-modal");f&&f.classList.remove("show"),document.getElementById("recipe-deploy-title").textContent=`Deploy ${m.name}`,z(),C(),A.classList.add("show")}function z(){document.querySelectorAll("#recipe-steps .recipe-step").forEach(m=>{const f=parseInt(m.dataset.step);m.classList.toggle("active",f===h),m.classList.toggle("completed",f<h)});for(let m=1;m<=4;m++){const f=document.getElementById(`recipe-step-${m}`);f&&(f.style.display=m===h?"":"none")}R.style.display=h>1&&h<4?"":"none",h===4?(y.style.display="none",D.textContent="Close"):h===3?(y.textContent="\u{1F680} Deploy",y.style.display="",D.textContent="Cancel"):(y.textContent="Next",y.style.display="",D.textContent="Cancel")}function C(){const m=document.getElementById("recipe-component-list");m.innerHTML="";const f=j.components||[];for(const B of f){const w=document.createElement("div");w.style.cssText="display: flex; align-items: center; gap: 12px; padding: 12px; border-radius: 8px; background: var(--card-bg); border: 1px solid var(--border);";const L=B.required,o=B.internal;w.innerHTML=`
         <input type="checkbox" ${L?"checked disabled":"checked"} data-component-id="${B.id}"
           style="width: 18px; height: 18px; accent-color: var(--accent);" />
         <div style="flex: 1;">
@@ -463,15 +463,15 @@ Try refreshing in a moment if you see a certificate error.`,"warning",1e4),!1}};
           </div>
           ${B.note?`<div style="font-size: 0.75rem; color: var(--warn-fg); margin-top: 4px;">\u26A0 ${escapeHtml(B.note)}</div>`:""}
         </div>
-      `,m.appendChild(w)}}function H(){const m=document.getElementById("recipe-volumes-section"),f=document.getElementById("recipe-volume-list"),B=R.sharedVolumes;if(B&&Object.keys(B).length>0){m.style.display="",f.innerHTML="";for(const[w,L]of Object.entries(B)){const o=document.createElement("div");o.style.cssText="display: grid; gap: 4px;",o.innerHTML=`
+      `,m.appendChild(w)}}function M(){const m=document.getElementById("recipe-volumes-section"),f=document.getElementById("recipe-volume-list"),B=j.sharedVolumes;if(B&&Object.keys(B).length>0){m.style.display="",f.innerHTML="";for(const[w,L]of Object.entries(B)){const o=document.createElement("div");o.style.cssText="display: grid; gap: 4px;",o.innerHTML=`
           <label style="font-weight: 500; font-size: 0.85rem;">${escapeHtml(L.label||w)}</label>
           <input type="text" data-volume-key="${w}" value="${escapeHtml(L.defaultPath||"")}"
             placeholder="${escapeHtml(L.defaultPath||"/path")}"
             style="width: 100%; padding: 8px 12px; background: var(--card-bg); color: var(--fg); border: 1px solid var(--border); border-radius: 6px; font-family: monospace; font-size: 0.85rem;" />
           <div class="form-hint-sm">${escapeHtml(L.description||"")}</div>
-        `,f.appendChild(o)}}else m.style.display="none"}function b(){const m=document.getElementById("recipe-review-content"),f=d(),B=document.querySelectorAll("#recipe-volume-list input[data-volume-key]"),w={};B.forEach(l=>{w[l.dataset.volumeKey]=l.value});const L=document.getElementById("recipe-timezone").value||"UTC",o=document.getElementById("recipe-ip").value||"host.docker.internal",p=document.getElementById("recipe-tailscale").checked;m.innerHTML=`
-      <div style="font-weight: 600; font-size: 1rem; margin-bottom: 12px;">${escapeHtml(R.name)}</div>
-      <div style="color: var(--muted); margin-bottom: 16px;">${escapeHtml(R.description||"")}</div>
+        `,f.appendChild(o)}}else m.style.display="none"}function b(){const m=document.getElementById("recipe-review-content"),f=d(),B=document.querySelectorAll("#recipe-volume-list input[data-volume-key]"),w={};B.forEach(l=>{w[l.dataset.volumeKey]=l.value});const L=document.getElementById("recipe-timezone").value||"UTC",o=document.getElementById("recipe-ip").value||"host.docker.internal",u=document.getElementById("recipe-tailscale").checked;m.innerHTML=`
+      <div style="font-weight: 600; font-size: 1rem; margin-bottom: 12px;">${escapeHtml(j.name)}</div>
+      <div style="color: var(--muted); margin-bottom: 16px;">${escapeHtml(j.description||"")}</div>
 
       <div style="margin-bottom: 12px;">
         <strong>Components (${f.length}):</strong>
@@ -484,31 +484,31 @@ Try refreshing in a moment if you see a certificate error.`,"warning",1e4),!1}};
 
       ${Object.keys(w).length>0?`<div style="margin-bottom: 12px;">
         <strong>Volumes:</strong>
-        ${Object.entries(w).map(([l,y])=>`<div style="font-size: 0.85rem; font-family: monospace; color: var(--muted);">${l}: ${escapeHtml(y)}</div>`).join("")}
+        ${Object.entries(w).map(([l,g])=>`<div style="font-size: 0.85rem; font-family: monospace; color: var(--muted);">${l}: ${escapeHtml(g)}</div>`).join("")}
       </div>`:""}
 
       <div style="font-size: 0.85rem; color: var(--muted);">
-        Timezone: ${escapeHtml(L)} &bull; IP: ${escapeHtml(o)} ${p?"&bull; Tailscale only":""}
+        Timezone: ${escapeHtml(L)} &bull; IP: ${escapeHtml(o)} ${u?"&bull; Tailscale only":""}
       </div>
 
-      ${R.network?`<div style="font-size: 0.85rem; color: var(--muted); margin-top: 4px;">Docker network: <code>${escapeHtml(R.network.name)}</code></div>`:""}
-    `}function d(){const m=document.querySelectorAll("#recipe-component-list input[data-component-id]"),f=new Set;m.forEach(w=>{w.checked&&f.add(w.dataset.componentId)});const B=R.components||[];return B.filter(w=>w.required).forEach(w=>f.add(w.id)),B.filter(w=>f.has(w.id))}async function v(){const m=document.getElementById("recipe-progress-list"),f=document.getElementById("recipe-deploy-result");f.style.display="none",m.innerHTML="";const B=d();for(const p of B){const l=document.createElement("div");l.id=`recipe-progress-${p.id}`,l.style.cssText="display: flex; align-items: center; gap: 10px; padding: 10px 12px; border-radius: 6px; background: var(--card-bg); border: 1px solid var(--border); font-size: 0.85rem;",l.innerHTML=`
+      ${j.network?`<div style="font-size: 0.85rem; color: var(--muted); margin-top: 4px;">Docker network: <code>${escapeHtml(j.network.name)}</code></div>`:""}
+    `}function d(){const m=document.querySelectorAll("#recipe-component-list input[data-component-id]"),f=new Set;m.forEach(w=>{w.checked&&f.add(w.dataset.componentId)});const B=j.components||[];return B.filter(w=>w.required).forEach(w=>f.add(w.id)),B.filter(w=>f.has(w.id))}async function v(){const m=document.getElementById("recipe-progress-list"),f=document.getElementById("recipe-deploy-result");f.style.display="none",m.innerHTML="";const B=d();for(const u of B){const l=document.createElement("div");l.id=`recipe-progress-${u.id}`,l.style.cssText="display: flex; align-items: center; gap: 10px; padding: 10px 12px; border-radius: 6px; background: var(--card-bg); border: 1px solid var(--border); font-size: 0.85rem;",l.innerHTML=`
         <span class="recipe-progress-icon" style="font-size: 1.1rem;">\u23F3</span>
-        <span style="flex:1; font-weight: 500;">${escapeHtml(p.role||p.id)}</span>
+        <span style="flex:1; font-weight: 500;">${escapeHtml(u.role||u.id)}</span>
         <span class="recipe-progress-status" style="color: var(--muted);">Queued</span>
-      `,m.appendChild(l)}const w=document.querySelectorAll("#recipe-volume-list input[data-volume-key]"),L={};w.forEach(p=>{L[p.dataset.volumeKey]=p.value});const o={selectedComponents:B.map(p=>p.id),sharedConfig:{ip:document.getElementById("recipe-ip").value||"host.docker.internal",timezone:document.getElementById("recipe-timezone").value||"UTC",tailscaleOnly:document.getElementById("recipe-tailscale").checked,volumes:L},componentOverrides:{}};for(const p of B)S(p.id,"deploying","Deploying...");try{const l=await(await secureFetch("/api/v1/recipes/deploy",{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify({recipeId:R.id,config:o})})).json();if(l.success){for(const y of l.deployed||[])S(y.id,"success",y.url?`Running \u2192 ${y.url}`:"Running");for(const y of l.errors||[])S(y.componentId,"error",y.error);f.style.display="",f.innerHTML=`
+      `,m.appendChild(l)}const w=document.querySelectorAll("#recipe-volume-list input[data-volume-key]"),L={};w.forEach(u=>{L[u.dataset.volumeKey]=u.value});const o={selectedComponents:B.map(u=>u.id),sharedConfig:{ip:document.getElementById("recipe-ip").value||"host.docker.internal",timezone:document.getElementById("recipe-timezone").value||"UTC",tailscaleOnly:document.getElementById("recipe-tailscale").checked,volumes:L},componentOverrides:{}};for(const u of B)S(u.id,"deploying","Deploying...");try{const l=await(await secureFetch("/api/v1/recipes/deploy",{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify({recipeId:j.id,config:o})})).json();if(l.success){for(const g of l.deployed||[])S(g.id,"success",g.url?`Running \u2192 ${g.url}`:"Running");for(const g of l.errors||[])S(g.componentId,"error",g.error);f.style.display="",f.innerHTML=`
           <div style="padding: 14px; border-radius: 8px; background: rgba(46,204,113,0.1); border: 1px solid rgba(46,204,113,0.3);">
             <div style="font-weight: 600; color: var(--ok-fg); margin-bottom: 6px;">${escapeHtml(l.message||"Deployed!")}</div>
             ${l.setupInstructions?`<div style="font-size: 0.8rem; color: var(--muted); margin-top: 8px;">
               <strong>Setup tips:</strong>
-              <ul style="margin: 4px 0 0 16px; padding: 0;">${l.setupInstructions.map(y=>`<li>${escapeHtml(y)}</li>`).join("")}</ul>
+              <ul style="margin: 4px 0 0 16px; padding: 0;">${l.setupInstructions.map(g=>`<li>${escapeHtml(g)}</li>`).join("")}</ul>
             </div>`:""}
           </div>
-        `,showNotification(`${R.name} recipe deployed successfully!`,"success",5e3),window.loadServices&&window.loadServices()}else f.style.display="",f.innerHTML=`<div style="padding: 14px; border-radius: 8px; background: rgba(231,76,60,0.1); border: 1px solid rgba(231,76,60,0.3); color: var(--bad-fg);">
+        `,showNotification(`${j.name} recipe deployed successfully!`,"success",5e3),window.loadServices&&window.loadServices()}else f.style.display="",f.innerHTML=`<div style="padding: 14px; border-radius: 8px; background: rgba(231,76,60,0.1); border: 1px solid rgba(231,76,60,0.3); color: var(--bad-fg);">
           <strong>Deployment failed:</strong> ${escapeHtml(l.error||"Unknown error")}
-        </div>`,showNotification(`Recipe deployment failed: ${l.error}`,"error",5e3)}catch(p){f.style.display="",f.innerHTML=`<div style="padding: 14px; border-radius: 8px; background: rgba(231,76,60,0.1); border: 1px solid rgba(231,76,60,0.3); color: var(--bad-fg);">
-        <strong>Network error:</strong> ${escapeHtml(p.message)}
-      </div>`}}function S(m,f,B){const w=document.getElementById(`recipe-progress-${m}`);if(!w)return;const L=w.querySelector(".recipe-progress-icon"),o=w.querySelector(".recipe-progress-status");f==="deploying"?(L.textContent="\u23F3",o.style.color="var(--accent)"):f==="success"?(L.textContent="\u2705",o.style.color="var(--ok-fg)"):f==="error"&&(L.textContent="\u274C",o.style.color="var(--bad-fg)"),o.textContent=B}g.addEventListener("click",()=>{if(h===3){h=4,z(),v();return}h<3&&(h++,z(),h===2&&H(),h===3&&b())}),j.addEventListener("click",()=>{h>1&&h<4&&(h--,z())}),window.groupRecipeCards=function(){const m=document.querySelectorAll(".service-card[data-recipe-id]");if(m.length===0)return;const f={};m.forEach(B=>{const w=B.dataset.recipeId;f[w]||(f[w]=[]),f[w].push(B)});for(const[B,w]of Object.entries(f))w.length<2||w.forEach((L,o)=>{if(L.style.borderLeft="3px solid rgba(142,68,173,0.5)",o===0){let p=L.querySelector(".recipe-group-label");p||(p=document.createElement("div"),p.className="recipe-group-label",p.style.cssText="position: absolute; top: -8px; left: 12px; font-size: 0.6rem; padding: 1px 8px; border-radius: 8px; background: rgba(142,68,173,0.3); color: #d4a5ff; font-weight: 600; text-transform: uppercase; letter-spacing: 0.5px;",p.textContent=B.replace(/-/g," "),L.style.position="relative",L.appendChild(p))}})},window.manageRecipe=async function(m,f){const B=`/api/v1/recipes/${m}/${f}`,w=f==="remove"?"DELETE":"POST",L=f==="remove"?`/api/v1/recipes/${m}`:B;if(!(f==="remove"&&!confirm(`Remove the entire ${m} recipe? This will delete all containers and configuration.`)))try{const p=await(await secureFetch(L,{method:w})).json();p.success?(showNotification(`Recipe ${f}: ${p.results?.filter(l=>l.status!=="failed").length||0} components processed`,"success",4e3),window.loadServices&&window.loadServices()):showNotification(`Recipe ${f} failed: ${p.error}`,"error",5e3)}catch(o){showNotification(`Network error: ${o.message}`,"error",5e3)}};const O=document.createElement("style");O.textContent=`
+        </div>`,showNotification(`Recipe deployment failed: ${l.error}`,"error",5e3)}catch(u){f.style.display="",f.innerHTML=`<div style="padding: 14px; border-radius: 8px; background: rgba(231,76,60,0.1); border: 1px solid rgba(231,76,60,0.3); color: var(--bad-fg);">
+        <strong>Network error:</strong> ${escapeHtml(u.message)}
+      </div>`}}function S(m,f,B){const w=document.getElementById(`recipe-progress-${m}`);if(!w)return;const L=w.querySelector(".recipe-progress-icon"),o=w.querySelector(".recipe-progress-status");f==="deploying"?(L.textContent="\u23F3",o.style.color="var(--accent)"):f==="success"?(L.textContent="\u2705",o.style.color="var(--ok-fg)"):f==="error"&&(L.textContent="\u274C",o.style.color="var(--bad-fg)"),o.textContent=B}y.addEventListener("click",()=>{if(h===3){h=4,z(),v();return}h<3&&(h++,z(),h===2&&M(),h===3&&b())}),R.addEventListener("click",()=>{h>1&&h<4&&(h--,z())}),window.groupRecipeCards=function(){const m=document.querySelectorAll(".service-card[data-recipe-id]");if(m.length===0)return;const f={};m.forEach(B=>{const w=B.dataset.recipeId;f[w]||(f[w]=[]),f[w].push(B)});for(const[B,w]of Object.entries(f))w.length<2||w.forEach((L,o)=>{if(L.style.borderLeft="3px solid rgba(142,68,173,0.5)",o===0){let u=L.querySelector(".recipe-group-label");u||(u=document.createElement("div"),u.className="recipe-group-label",u.style.cssText="position: absolute; top: -8px; left: 12px; font-size: 0.6rem; padding: 1px 8px; border-radius: 8px; background: rgba(142,68,173,0.3); color: #d4a5ff; font-weight: 600; text-transform: uppercase; letter-spacing: 0.5px;",u.textContent=B.replace(/-/g," "),L.style.position="relative",L.appendChild(u))}})},window.manageRecipe=async function(m,f){const B=`/api/v1/recipes/${m}/${f}`,w=f==="remove"?"DELETE":"POST",L=f==="remove"?`/api/v1/recipes/${m}`:B;if(!(f==="remove"&&!confirm(`Remove the entire ${m} recipe? This will delete all containers and configuration.`)))try{const u=await(await secureFetch(L,{method:w})).json();u.success?(showNotification(`Recipe ${f}: ${u.results?.filter(l=>l.status!=="failed").length||0} components processed`,"success",4e3),window.loadServices&&window.loadServices()):showNotification(`Recipe ${f} failed: ${u.error}`,"error",5e3)}catch(o){showNotification(`Network error: ${o.message}`,"error",5e3)}};const O=document.createElement("style");O.textContent=`
     .recipe-step {
       flex: 1;
       text-align: center;
@@ -550,7 +550,7 @@ Try refreshing in a moment if you see a certificate error.`,"warning",1e4),!1}};
     .recipe-step-panel {
       min-height: 180px;
     }
-  `,document.head.appendChild(O),k()})(),(function(){document.getElementById("reload-caddy-top")?.addEventListener("click",async()=>{const x=document.getElementById("reload-caddy-top"),E=x.textContent;try{x.textContent="\u23F3 Reloading...",x.disabled=!0;const R=await secureFetch("/api/v1/caddy/reload",{method:"POST",headers:{"Content-Type":"application/json"}}),h=await R.json();if(R.ok&&h.success)x.textContent="\u2705 Reloaded!",setTimeout(()=>{x.textContent=E,x.disabled=!1},2e3);else throw new Error(h.error||"Reload failed")}catch(R){x.textContent="\u274C Failed",showNotification(`Failed to reload Caddy: ${R.message}`,"error"),setTimeout(()=>{x.textContent=E,x.disabled=!1},2e3)}})})(),(function(){injectModal("error-log-modal",`<div id="error-log-modal" class="weather-modal">
+  `,document.head.appendChild(O),k()})(),(function(){document.getElementById("reload-caddy-top")?.addEventListener("click",async()=>{const x=document.getElementById("reload-caddy-top"),E=x.textContent;try{x.textContent="\u23F3 Reloading...",x.disabled=!0;const j=await secureFetch("/api/v1/caddy/reload",{method:"POST",headers:{"Content-Type":"application/json"}}),h=await j.json();if(j.ok&&h.success)x.textContent="\u2705 Reloaded!",setTimeout(()=>{x.textContent=E,x.disabled=!1},2e3);else throw new Error(h.error||"Reload failed")}catch(j){x.textContent="\u274C Failed",showNotification(`Failed to reload Caddy: ${j.message}`,"error"),setTimeout(()=>{x.textContent=E,x.disabled=!1},2e3)}})})(),(function(){injectModal("error-log-modal",`<div id="error-log-modal" class="weather-modal">
     <div class="weather-modal-content" style="min-width: 950px; max-width: 1150px;">
       <h3>\u{1F4CB} Error Logs</h3>
       <p class="modal-subtitle">
@@ -597,8 +597,8 @@ Try refreshing in a moment if you see a certificate error.`,"warning",1e4),!1}};
         <button id="error-log-close">Close</button>
       </div>
     </div>
-  </div>`);const x=document.getElementById("error-log-modal"),E=document.getElementById("view-error-logs"),R=document.getElementById("error-log-refresh"),h=document.getElementById("error-log-clear"),P=document.getElementById("error-log-close"),A=document.getElementById("error-log-level"),D=document.getElementById("error-log-context"),j=document.getElementById("error-log-search"),g=document.getElementById("error-log-since"),$=document.getElementById("error-log-until"),k=document.getElementById("error-log-container"),M=document.getElementById("error-log-load-more"),T=document.getElementById("error-log-total"),z=50;let C=0,H=null,b=0,d=[];function v(L){if(!L)return null;const o=new Date(L);return isNaN(o.getTime())?null:o.toISOString()}async function S(){try{const L=await fetch("/api/v1/error-logs/contexts");if(!L.ok)return;const o=await L.json();if(!o.success||!Array.isArray(o.contexts))return;d=o.contexts;const p=D.value;D.innerHTML='<option value="">All</option>';for(const l of o.contexts){const y=document.createElement("option");y.value=l.name,y.textContent=`${l.name} (${l.count})`,D.appendChild(y)}p&&o.contexts.some(l=>l.name===p)&&(D.value=p)}catch{}}function O(){const L=new URLSearchParams;L.set("limit",String(z)),L.set("offset",String(C)),A.value&&L.set("level",A.value),D.value&&L.set("context",D.value);const o=v(g.value),p=v($.value);o&&L.set("since",o),p&&L.set("until",p);const l=(j.value||"").trim();return l&&L.set("search",l),L}async function m(L){try{L?(H&&H.abort(),H=new AbortController):(H&&H.abort(),H=new AbortController,C=0,b++,k.innerHTML='<div class="panel-empty"><span class="brand-spinner"></span> Loading...</div>');const o=b,p=O(),l=await fetch("/api/v1/error-logs?"+p.toString(),{signal:H.signal});if(!l.ok){k.innerHTML=`<div class="panel-empty" style="color: var(--bad-fg);">Failed: HTTP ${l.status}</div>`,M.style.display="none",T.textContent="";return}const y=await l.json();if(!y.success){k.innerHTML=`<div class="panel-empty" style="color: var(--bad-fg);">Failed: ${escapeHtml(y.error||"unknown")}</div>`,M.style.display="none",T.textContent="";return}if(!L&&o!==b)return;const u=Array.isArray(y.logs)?y.logs:[];if(u.length===0&&!L){const e=y.filters&&(y.filters.level||y.filters.context||y.filters.search||y.filters.since||y.filters.until)?"No error log entries match your filters.":"\u2705 No errors logged! Everything is working smoothly.";k.innerHTML=`<div class="panel-empty"><span class="empty-icon">\u{1F4CB}</span>${escapeHtml(e)}</div>`,M.style.display="none",T.textContent=y.total?`${y.total} total`:"";return}let t="";L||(t='<table style="width: 100%; border-collapse: collapse; font-size: 0.82rem;">',t+='<tr style="border-bottom: 1px solid var(--border); color: var(--muted);">',t+='<th style="padding: 6px; text-align: left; width: 160px;">When</th>',t+='<th style="padding: 6px; text-align: left; width: 80px;">Level</th>',t+='<th style="padding: 6px; text-align: left; width: 140px;">Context</th>',t+='<th style="padding: 6px; text-align: left;">Message</th>',t+='<th style="padding: 6px; text-align: left; width: 110px;">IP</th>',t+="</tr>");for(const e of u){const s=(e.level||"?").toUpperCase(),n=s==="ERR"?"var(--bad-fg)":s==="WARN"?"var(--warn-fg, #f0c674)":"var(--muted)",r=e.timestamp?new Date(e.timestamp).toLocaleString():"\u2014",a=e.context||"\u2014",i=(e.error||"").split(`
-`)[0],c=e.request&&e.request.ip||"";t+='<tr style="border-bottom: 1px solid var(--border); cursor: pointer;" class="error-log-row">',t+=`<td style="padding: 6px; color: var(--muted);" title="${escapeHtml(e.timestamp||"")}">${escapeHtml(r)}</td>`,t+=`<td style="padding: 6px;"><span style="color: ${n}; font-weight: 600;">${escapeHtml(s)}</span></td>`,t+=`<td style="padding: 6px; font-family: monospace; font-size: 0.78rem;">${escapeHtml(a)}</td>`,t+=`<td style="padding: 6px;">${escapeHtml(i)}</td>`,t+=`<td style="padding: 6px; font-family: monospace; font-size: 0.78rem;">${escapeHtml(c)}</td>`,t+="</tr>",e.detail&&(t+=`<tr class="error-log-detail" style="display: none;"><td colspan="5" style="padding: 6px 6px 10px; font-size: 0.78rem; color: var(--muted);"><pre style="margin: 0; white-space: pre-wrap; font-family: monospace; max-height: 320px; overflow: auto;">${escapeHtml(e.detail)}</pre></td></tr>`)}if(!L)t+="</table>",k.innerHTML=t;else{const e=k.querySelector("table");e&&e.insertAdjacentHTML("beforeend",t)}C+=u.length,M.style.display=y.hasMore?"":"none",T.textContent=`${y.total} total${y.hasMore?" (showing "+C+")":""}`,k.querySelectorAll(".error-log-row").forEach(e=>{e.dataset.wired||(e.dataset.wired="true",e.addEventListener("click",()=>{const s=e.nextElementSibling;s&&s.classList.contains("error-log-detail")&&(s.style.display=s.style.display==="none"?"":"none")}))})}catch(o){if(o&&o.name==="AbortError")return;k.innerHTML=`<div class="panel-empty" style="color: var(--bad-fg);">Failed: ${escapeHtml(o.message)}</div>`,T.textContent=""}}async function f(){if(confirm("Clear the entire error log? This cannot be undone."))try{const o=await(await secureFetch("/api/v1/error-logs",{method:"DELETE",headers:{"content-type":"application/json"},body:JSON.stringify({confirm:"CLEAR"})})).json();o.success?(await S(),m(!1),showNotification("\u2705 Error logs cleared","success",3e3)):showNotification("\u274C "+(o.error||"Clear failed"),"error",4e3)}catch(L){showNotification("\u274C "+L.message,"error",4e3)}}let B;function w(){A?.addEventListener("change",()=>m(!1)),D?.addEventListener("change",()=>m(!1)),j?.addEventListener("input",()=>{clearTimeout(B),B=setTimeout(()=>m(!1),250)});let L;[g,$].forEach(o=>{o?.addEventListener("change",()=>{clearTimeout(L),L=setTimeout(()=>m(!1),250)})}),R?.addEventListener("click",()=>m(!1)),M?.addEventListener("click",()=>m(!0)),h?.addEventListener("click",f),wireModal(x,P)}E?.addEventListener("click",async()=>{x?.classList.add("show"),await S(),m(!1)}),w()})(),(function(){injectModal("container-logs-modal",`<div id="container-logs-modal" class="weather-modal" style="z-index: 1001;">
+  </div>`);const x=document.getElementById("error-log-modal"),E=document.getElementById("view-error-logs"),j=document.getElementById("error-log-refresh"),h=document.getElementById("error-log-clear"),P=document.getElementById("error-log-close"),A=document.getElementById("error-log-level"),D=document.getElementById("error-log-context"),R=document.getElementById("error-log-search"),y=document.getElementById("error-log-since"),$=document.getElementById("error-log-until"),k=document.getElementById("error-log-container"),H=document.getElementById("error-log-load-more"),T=document.getElementById("error-log-total"),z=50;let C=0,M=null,b=0,d=[];function v(L){if(!L)return null;const o=new Date(L);return isNaN(o.getTime())?null:o.toISOString()}async function S(){try{const L=await fetch("/api/v1/error-logs/contexts");if(!L.ok)return;const o=await L.json();if(!o.success||!Array.isArray(o.contexts))return;d=o.contexts;const u=D.value;D.innerHTML='<option value="">All</option>';for(const l of o.contexts){const g=document.createElement("option");g.value=l.name,g.textContent=`${l.name} (${l.count})`,D.appendChild(g)}u&&o.contexts.some(l=>l.name===u)&&(D.value=u)}catch{}}function O(){const L=new URLSearchParams;L.set("limit",String(z)),L.set("offset",String(C)),A.value&&L.set("level",A.value),D.value&&L.set("context",D.value);const o=v(y.value),u=v($.value);o&&L.set("since",o),u&&L.set("until",u);const l=(R.value||"").trim();return l&&L.set("search",l),L}async function m(L){try{L?(M&&M.abort(),M=new AbortController):(M&&M.abort(),M=new AbortController,C=0,b++,k.innerHTML='<div class="panel-empty"><span class="brand-spinner"></span> Loading...</div>');const o=b,u=O(),l=await fetch("/api/v1/error-logs?"+u.toString(),{signal:M.signal});if(!l.ok){k.innerHTML=`<div class="panel-empty" style="color: var(--bad-fg);">Failed: HTTP ${l.status}</div>`,H.style.display="none",T.textContent="";return}const g=await l.json();if(!g.success){k.innerHTML=`<div class="panel-empty" style="color: var(--bad-fg);">Failed: ${escapeHtml(g.error||"unknown")}</div>`,H.style.display="none",T.textContent="";return}if(!L&&o!==b)return;const p=Array.isArray(g.logs)?g.logs:[];if(p.length===0&&!L){const e=g.filters&&(g.filters.level||g.filters.context||g.filters.search||g.filters.since||g.filters.until)?"No error log entries match your filters.":"\u2705 No errors logged! Everything is working smoothly.";k.innerHTML=`<div class="panel-empty"><span class="empty-icon">\u{1F4CB}</span>${escapeHtml(e)}</div>`,H.style.display="none",T.textContent=g.total?`${g.total} total`:"";return}let t="";L||(t='<table style="width: 100%; border-collapse: collapse; font-size: 0.82rem;">',t+='<tr style="border-bottom: 1px solid var(--border); color: var(--muted);">',t+='<th style="padding: 6px; text-align: left; width: 160px;">When</th>',t+='<th style="padding: 6px; text-align: left; width: 80px;">Level</th>',t+='<th style="padding: 6px; text-align: left; width: 140px;">Context</th>',t+='<th style="padding: 6px; text-align: left;">Message</th>',t+='<th style="padding: 6px; text-align: left; width: 110px;">IP</th>',t+="</tr>");for(const e of p){const s=(e.level||"?").toUpperCase(),n=s==="ERR"?"var(--bad-fg)":s==="WARN"?"var(--warn-fg, #f0c674)":"var(--muted)",r=e.timestamp?new Date(e.timestamp).toLocaleString():"\u2014",a=e.context||"\u2014",i=(e.error||"").split(`
+`)[0],c=e.request&&e.request.ip||"";t+='<tr style="border-bottom: 1px solid var(--border); cursor: pointer;" class="error-log-row">',t+=`<td style="padding: 6px; color: var(--muted);" title="${escapeHtml(e.timestamp||"")}">${escapeHtml(r)}</td>`,t+=`<td style="padding: 6px;"><span style="color: ${n}; font-weight: 600;">${escapeHtml(s)}</span></td>`,t+=`<td style="padding: 6px; font-family: monospace; font-size: 0.78rem;">${escapeHtml(a)}</td>`,t+=`<td style="padding: 6px;">${escapeHtml(i)}</td>`,t+=`<td style="padding: 6px; font-family: monospace; font-size: 0.78rem;">${escapeHtml(c)}</td>`,t+="</tr>",e.detail&&(t+=`<tr class="error-log-detail" style="display: none;"><td colspan="5" style="padding: 6px 6px 10px; font-size: 0.78rem; color: var(--muted);"><pre style="margin: 0; white-space: pre-wrap; font-family: monospace; max-height: 320px; overflow: auto;">${escapeHtml(e.detail)}</pre></td></tr>`)}if(!L)t+="</table>",k.innerHTML=t;else{const e=k.querySelector("table");e&&e.insertAdjacentHTML("beforeend",t)}C+=p.length,H.style.display=g.hasMore?"":"none",T.textContent=`${g.total} total${g.hasMore?" (showing "+C+")":""}`,k.querySelectorAll(".error-log-row").forEach(e=>{e.dataset.wired||(e.dataset.wired="true",e.addEventListener("click",()=>{const s=e.nextElementSibling;s&&s.classList.contains("error-log-detail")&&(s.style.display=s.style.display==="none"?"":"none")}))})}catch(o){if(o&&o.name==="AbortError")return;k.innerHTML=`<div class="panel-empty" style="color: var(--bad-fg);">Failed: ${escapeHtml(o.message)}</div>`,T.textContent=""}}async function f(){if(confirm("Clear the entire error log? This cannot be undone."))try{const o=await(await secureFetch("/api/v1/error-logs",{method:"DELETE",headers:{"content-type":"application/json"},body:JSON.stringify({confirm:"CLEAR"})})).json();o.success?(await S(),m(!1),showNotification("\u2705 Error logs cleared","success",3e3)):showNotification("\u274C "+(o.error||"Clear failed"),"error",4e3)}catch(L){showNotification("\u274C "+L.message,"error",4e3)}}let B;function w(){A?.addEventListener("change",()=>m(!1)),D?.addEventListener("change",()=>m(!1)),R?.addEventListener("input",()=>{clearTimeout(B),B=setTimeout(()=>m(!1),250)});let L;[y,$].forEach(o=>{o?.addEventListener("change",()=>{clearTimeout(L),L=setTimeout(()=>m(!1),250)})}),j?.addEventListener("click",()=>m(!1)),H?.addEventListener("click",()=>m(!0)),h?.addEventListener("click",f),wireModal(x,P)}E?.addEventListener("click",async()=>{x?.classList.add("show"),await S(),m(!1)}),w()})(),(function(){injectModal("container-logs-modal",`<div id="container-logs-modal" class="weather-modal" style="z-index: 1001;">
     <div class="weather-modal-content" style="min-width: 900px; max-width: 95vw; height: 80vh; display: flex; flex-direction: column;">
       <div class="logs-header" style="display: flex; justify-content: space-between; align-items: center; padding-bottom: 12px; border-bottom: 1px solid var(--border); margin-bottom: 12px;">
         <div>
@@ -648,14 +648,14 @@ Try refreshing in a moment if you see a certificate error.`,"warning",1e4),!1}};
         <button id="cl-close-btn" class="btn-secondary">Close</button>
       </div>
     </div>
-  </div>`);const x=document.getElementById("container-logs-modal"),E=document.getElementById("cl-container-select"),R=document.getElementById("cl-log-content"),h=document.getElementById("cl-log-search"),P=document.getElementById("cl-log-tail"),A=document.getElementById("cl-refresh"),D=document.getElementById("cl-stream"),j=document.getElementById("cl-download"),g=document.getElementById("cl-clear-search"),$=document.getElementById("cl-close"),k=document.getElementById("cl-close-btn"),M=document.getElementById("cl-stream-status"),T=document.getElementById("cl-stream-indicator"),z=document.getElementById("cl-stream-text"),C=document.getElementById("cl-line-count"),H=document.getElementById("cl-filter-count"),b=document.getElementById("cl-image"),d=document.getElementById("cl-status"),v=document.getElementById("cl-created");let S=null,O=[],m=[],f=null,B=!1,w=null;function L(i){if(!i)return"-";const c=new Date(i);return isNaN(c.getTime())?i:c.toLocaleString()}function o(i){if(!i)return"";const c=document.createElement("div");return c.textContent=i,c.innerHTML}function p(i,c){const I=i.stream==="stderr"?"log-stderr":"log-stdout",N=i.stream==="stderr"?"\u26A0\uFE0F":"\u{1F4E4}";return`
+  </div>`);const x=document.getElementById("container-logs-modal"),E=document.getElementById("cl-container-select"),j=document.getElementById("cl-log-content"),h=document.getElementById("cl-log-search"),P=document.getElementById("cl-log-tail"),A=document.getElementById("cl-refresh"),D=document.getElementById("cl-stream"),R=document.getElementById("cl-download"),y=document.getElementById("cl-clear-search"),$=document.getElementById("cl-close"),k=document.getElementById("cl-close-btn"),H=document.getElementById("cl-stream-status"),T=document.getElementById("cl-stream-indicator"),z=document.getElementById("cl-stream-text"),C=document.getElementById("cl-line-count"),M=document.getElementById("cl-filter-count"),b=document.getElementById("cl-image"),d=document.getElementById("cl-status"),v=document.getElementById("cl-created");let S=null,O=[],m=[],f=null,B=!1,w=null;function L(i){if(!i)return"-";const c=new Date(i);return isNaN(c.getTime())?i:c.toLocaleString()}function o(i){if(!i)return"";const c=document.createElement("div");return c.textContent=i,c.innerHTML}function u(i,c){const I=i.stream==="stderr"?"log-stderr":"log-stdout",N=i.stream==="stderr"?"\u26A0\uFE0F":"\u{1F4E4}";return`
       <div class="log-entry ${I}" data-index="${c}" style="padding: 4px 8px; border-bottom: 1px solid #333; display: flex; gap: 8px;">
         <span class="log-line-num" style="color: #666; min-width: 40px; text-align: right; user-select: none;">${c+1}</span>
         <span class="log-stream-icon" style="color: ${i.stream==="stderr"?"#f59e0b":"#22c55e"};">${N}</span>
         <span class="log-text" style="flex: 1; white-space: pre-wrap; word-break: break-all; color: #e5e5e5;">${o(i.text)}</span>
       </div>
-    `}function l(i,c=""){if(!i||i.length===0){R.innerHTML='<div class="logs-loading" style="color: var(--muted); text-align: center; padding: 40px;">No logs available</div>',C.textContent="0 lines",H.textContent="0 filtered";return}if(O=i,m=c?i.filter(I=>I.text&&I.text.toLowerCase().includes(c.toLowerCase())):i,C.textContent=`${i.length} lines`,H.textContent=c?`${m.length} of ${i.length} shown`:`${i.length} shown`,m.length===0){R.innerHTML=`<div class="logs-loading" style="color: var(--muted); text-align: center; padding: 40px;">No logs match "${o(c)}"</div>`;return}R.innerHTML=m.map((I,N)=>p(I,N)).join(""),R.scrollTop=R.scrollHeight}async function y(){try{const c=(await getJSON("/api/v1/logs/containers")).containers||[],I=E.value;E.innerHTML='<option value="">Select a container...</option>',c.forEach(N=>{const U=document.createElement("option");U.value=N.id,U.textContent=`${N.name} (${N.image.split(":")[0]}) - ${N.status}`,U.dataset.name=N.name,U.dataset.image=N.image,U.dataset.status=N.status,U.dataset.created=N.created,E.appendChild(U)}),I&&E.querySelector(`option[value="${I}"]`)&&(E.value=I,u(I))}catch(i){console.error("Failed to load containers:",i)}}function u(i){const c=E.querySelector(`option[value="${i}"]`);c&&(b.textContent=c.dataset.image||"-",d.textContent=c.dataset.status||"-",d.style.color=c.dataset.status==="running"?"var(--ok-fg, #4ade80)":"var(--bad-fg, #ef4444)",v.textContent=L(c.dataset.created))}async function t(){const i=E.value;if(!i){R.innerHTML='<div class="logs-loading" style="color: var(--muted); text-align: center; padding: 40px;">Select a container to view logs</div>';return}s(),S=i,u(i);const c=P.value,I=h.value.trim();R.innerHTML='<div class="logs-loading" style="color: var(--muted); text-align: center; padding: 40px;">Loading logs...</div>';try{const N=`/api/v1/logs/container/${i}${c!=="all"?`?tail=${c}`:""}`,U=await getJSON(N);U.logs&&U.logs.length>0?l(U.logs,I):(R.innerHTML='<div class="logs-loading" style="color: var(--muted); text-align: center; padding: 40px;">No logs found for this container</div>',C.textContent="0 lines",H.textContent="0 filtered")}catch(N){R.innerHTML=`<div class="logs-loading" style="color: var(--bad-fg, #ef4444); text-align: center; padding: 40px;">Error loading logs: ${o(N.message)}</div>`}}function e(){const i=E.value;if(!i)return;s(),B=!0,D.textContent="\u23F9 Stop",M.style.display="flex",T.textContent="\u{1F7E2}",z.textContent="Connecting...";const c=`/api/v1/logs/stream/${i}`;f=new EventSource(c),f.onopen=()=>{T.textContent="\u{1F7E2}",z.textContent="Connected - streaming logs"},f.onmessage=I=>{try{const N=JSON.parse(I.data);if(N.error){T.textContent="\u{1F534}",z.textContent=`Error: ${N.error}`;return}O.push(N),m.push(N),C.textContent=`${O.length} lines`,H.textContent=`${m.length} shown`;const U=h.value.trim();if(!U||N.text&&N.text.toLowerCase().includes(U.toLowerCase())){const _=document.createElement("div");_.innerHTML=p(N,m.length-1);const F=_.firstElementChild;F.style.background="#1a3a1a",R.appendChild(F),R.scrollTop=R.scrollHeight}}catch(N){console.error("Error parsing log:",N)}},f.onerror=()=>{T.textContent="\u{1F534}",z.textContent="Disconnected",B=!1,D.textContent="\u25B6 Stream"},x._eventSource=f}function s(){f&&(f.close(),f=null),x._eventSource&&(x._eventSource.close(),x._eventSource=null),B=!1,D.textContent="\u25B6 Stream",M.style.display="none"}function n(){if(!O||O.length===0){showNotification("No logs to download","error");return}const i=E.querySelector(`option[value="${S}"]`)?.dataset.name||S,c=new Date().toISOString().replace(/[:.]/g,"-"),I=`${i}-logs-${c}.txt`,N=O.map(q=>{const J=q.timestamp||"",X=q.stream==="stderr"?"[ERR]":"[OUT]";return`${J?J+" ":""}${X} ${q.text}`}).join(`
-`),U=new Blob([N],{type:"text/plain"}),_=URL.createObjectURL(U),F=document.createElement("a");F.href=_,F.download=I,document.body.appendChild(F),F.click(),document.body.removeChild(F),URL.revokeObjectURL(_),showNotification(`Downloaded ${O.length} log lines`,"success")}E?.addEventListener("change",()=>{t()}),P?.addEventListener("change",()=>{t()}),A?.addEventListener("click",()=>{t()}),D?.addEventListener("click",()=>{B?s():e()}),j?.addEventListener("click",()=>{n()}),g?.addEventListener("click",()=>{h.value="",l(O,"")}),h?.addEventListener("input",()=>{clearTimeout(w),w=setTimeout(()=>{l(O,h.value.trim())},300)}),h?.addEventListener("keydown",i=>{i.key==="Escape"&&(h.value="",l(O,""))}),document.getElementById("view-container-logs")?.addEventListener("click",()=>{x.classList.add("show"),y()});function a(){s(),x.classList.remove("show")}$?.addEventListener("click",a),k?.addEventListener("click",a),document.addEventListener("keydown",i=>{i.key==="Escape"&&x.classList.contains("show")&&a()}),x.addEventListener("click",i=>{i.target===x&&a()}),window.openContainerLogsModal=function(i,c){x.classList.add("show"),y().then(()=>{const I=Array.from(E.options).find(N=>N.value===i||N.dataset.name===c);I?(E.value=I.value,u(I.value),t()):i?(S=i,b.textContent=c||i,d.textContent="-",v.textContent="-",t()):R.innerHTML='<div class="logs-loading" style="color: var(--muted); text-align: center; padding: 40px;">Select a container to view logs</div>'})}})(),(function(){"use strict";const x=[{unit:"caddy",label:"Caddy (reverse proxy)"},{unit:"dashcaddy-api",label:"DashCaddy API (host systemd unit, not this container)"},{unit:"docker",label:"Docker daemon"},{unit:"ssh",label:"SSH server"},{unit:"systemd-journald",label:"systemd-journald"},{unit:"tailscaled",label:"Tailscale"},{unit:"networkd-dispatcher",label:"Networkd dispatcher"}];injectModal("journald-modal",`
+    `}function l(i,c=""){if(!i||i.length===0){j.innerHTML='<div class="logs-loading" style="color: var(--muted); text-align: center; padding: 40px;">No logs available</div>',C.textContent="0 lines",M.textContent="0 filtered";return}if(O=i,m=c?i.filter(I=>I.text&&I.text.toLowerCase().includes(c.toLowerCase())):i,C.textContent=`${i.length} lines`,M.textContent=c?`${m.length} of ${i.length} shown`:`${i.length} shown`,m.length===0){j.innerHTML=`<div class="logs-loading" style="color: var(--muted); text-align: center; padding: 40px;">No logs match "${o(c)}"</div>`;return}j.innerHTML=m.map((I,N)=>u(I,N)).join(""),j.scrollTop=j.scrollHeight}async function g(){try{const c=(await getJSON("/api/v1/logs/containers")).containers||[],I=E.value;E.innerHTML='<option value="">Select a container...</option>',c.forEach(N=>{const U=document.createElement("option");U.value=N.id,U.textContent=`${N.name} (${N.image.split(":")[0]}) - ${N.status}`,U.dataset.name=N.name,U.dataset.image=N.image,U.dataset.status=N.status,U.dataset.created=N.created,E.appendChild(U)}),I&&E.querySelector(`option[value="${I}"]`)&&(E.value=I,p(I))}catch(i){console.error("Failed to load containers:",i)}}function p(i){const c=E.querySelector(`option[value="${i}"]`);c&&(b.textContent=c.dataset.image||"-",d.textContent=c.dataset.status||"-",d.style.color=c.dataset.status==="running"?"var(--ok-fg, #4ade80)":"var(--bad-fg, #ef4444)",v.textContent=L(c.dataset.created))}async function t(){const i=E.value;if(!i){j.innerHTML='<div class="logs-loading" style="color: var(--muted); text-align: center; padding: 40px;">Select a container to view logs</div>';return}s(),S=i,p(i);const c=P.value,I=h.value.trim();j.innerHTML='<div class="logs-loading" style="color: var(--muted); text-align: center; padding: 40px;">Loading logs...</div>';try{const N=`/api/v1/logs/container/${i}${c!=="all"?`?tail=${c}`:""}`,U=await getJSON(N);U.logs&&U.logs.length>0?l(U.logs,I):(j.innerHTML='<div class="logs-loading" style="color: var(--muted); text-align: center; padding: 40px;">No logs found for this container</div>',C.textContent="0 lines",M.textContent="0 filtered")}catch(N){j.innerHTML=`<div class="logs-loading" style="color: var(--bad-fg, #ef4444); text-align: center; padding: 40px;">Error loading logs: ${o(N.message)}</div>`}}function e(){const i=E.value;if(!i)return;s(),B=!0,D.textContent="\u23F9 Stop",H.style.display="flex",T.textContent="\u{1F7E2}",z.textContent="Connecting...";const c=`/api/v1/logs/stream/${i}`;f=new EventSource(c),f.onopen=()=>{T.textContent="\u{1F7E2}",z.textContent="Connected - streaming logs"},f.onmessage=I=>{try{const N=JSON.parse(I.data);if(N.error){T.textContent="\u{1F534}",z.textContent=`Error: ${N.error}`;return}O.push(N),m.push(N),C.textContent=`${O.length} lines`,M.textContent=`${m.length} shown`;const U=h.value.trim();if(!U||N.text&&N.text.toLowerCase().includes(U.toLowerCase())){const _=document.createElement("div");_.innerHTML=u(N,m.length-1);const F=_.firstElementChild;F.style.background="#1a3a1a",j.appendChild(F),j.scrollTop=j.scrollHeight}}catch(N){console.error("Error parsing log:",N)}},f.onerror=()=>{T.textContent="\u{1F534}",z.textContent="Disconnected",B=!1,D.textContent="\u25B6 Stream"},x._eventSource=f}function s(){f&&(f.close(),f=null),x._eventSource&&(x._eventSource.close(),x._eventSource=null),B=!1,D.textContent="\u25B6 Stream",H.style.display="none"}function n(){if(!O||O.length===0){showNotification("No logs to download","error");return}const i=E.querySelector(`option[value="${S}"]`)?.dataset.name||S,c=new Date().toISOString().replace(/[:.]/g,"-"),I=`${i}-logs-${c}.txt`,N=O.map(q=>{const J=q.timestamp||"",X=q.stream==="stderr"?"[ERR]":"[OUT]";return`${J?J+" ":""}${X} ${q.text}`}).join(`
+`),U=new Blob([N],{type:"text/plain"}),_=URL.createObjectURL(U),F=document.createElement("a");F.href=_,F.download=I,document.body.appendChild(F),F.click(),document.body.removeChild(F),URL.revokeObjectURL(_),showNotification(`Downloaded ${O.length} log lines`,"success")}E?.addEventListener("change",()=>{t()}),P?.addEventListener("change",()=>{t()}),A?.addEventListener("click",()=>{t()}),D?.addEventListener("click",()=>{B?s():e()}),R?.addEventListener("click",()=>{n()}),y?.addEventListener("click",()=>{h.value="",l(O,"")}),h?.addEventListener("input",()=>{clearTimeout(w),w=setTimeout(()=>{l(O,h.value.trim())},300)}),h?.addEventListener("keydown",i=>{i.key==="Escape"&&(h.value="",l(O,""))}),document.getElementById("view-container-logs")?.addEventListener("click",()=>{x.classList.add("show"),g()});function a(){s(),x.classList.remove("show")}$?.addEventListener("click",a),k?.addEventListener("click",a),document.addEventListener("keydown",i=>{i.key==="Escape"&&x.classList.contains("show")&&a()}),x.addEventListener("click",i=>{i.target===x&&a()}),window.openContainerLogsModal=function(i,c){x.classList.add("show"),g().then(()=>{const I=Array.from(E.options).find(N=>N.value===i||N.dataset.name===c);I?(E.value=I.value,p(I.value),t()):i?(S=i,b.textContent=c||i,d.textContent="-",v.textContent="-",t()):j.innerHTML='<div class="logs-loading" style="color: var(--muted); text-align: center; padding: 40px;">Select a container to view logs</div>'})}})(),(function(){"use strict";const x=[{unit:"caddy",label:"Caddy (reverse proxy)"},{unit:"dashcaddy-api",label:"DashCaddy API (host systemd unit, not this container)"},{unit:"docker",label:"Docker daemon"},{unit:"ssh",label:"SSH server"},{unit:"systemd-journald",label:"systemd-journald"},{unit:"tailscaled",label:"Tailscale"},{unit:"networkd-dispatcher",label:"Networkd dispatcher"}];injectModal("journald-modal",`
     <div id="journald-modal" class="weather-modal" style="z-index: 1002;">
       <div class="weather-modal-content" style="min-width: 900px; max-width: 95vw; height: 80vh; display: flex; flex-direction: column;">
         <div class="logs-header" style="display: flex; justify-content: space-between; align-items: center; padding-bottom: 12px; border-bottom: 1px solid var(--border); margin-bottom: 12px;">
@@ -698,7 +698,7 @@ Try refreshing in a moment if you see a certificate error.`,"warning",1e4),!1}};
         </div>
       </div>
     </div>
-  `);const E=document.getElementById("journald-modal"),R=document.getElementById("jd-unit-select"),h=document.getElementById("jd-search"),P=document.getElementById("jd-tail"),A=document.getElementById("jd-refresh"),D=document.getElementById("jd-stream"),j=document.getElementById("jd-clear-search"),g=document.getElementById("jd-close"),$=document.getElementById("jd-close-btn"),k=document.getElementById("jd-content"),M=document.getElementById("jd-line-count"),T=document.getElementById("jd-filter-count"),z=document.getElementById("jd-overflow"),C=document.getElementById("jd-unit-display"),H=document.getElementById("jd-stream-state");let b=!1,d=[],v=!1,S=null,O=null;function m(u){const t=document.createElement("div");return t.textContent=String(u),t.innerHTML}function f(u){b=u,R.innerHTML="",x.forEach(t=>{const e=document.createElement("option");e.value=t.unit,e.textContent=t.label+" ("+t.unit+")",R.appendChild(e)}),R.disabled=!u,u?(A.disabled=!1,D.disabled=!1):(k.innerHTML='<div class="logs-loading" style="color: var(--muted); text-align: center; padding: 40px;">journald bind-mount not available in this container.<br/><small>Requires <code>/var/log/journal</code> + <code>/usr/bin/journalctl</code> mounted (start.sh).</small></div>',A.disabled=!0,D.disabled=!0)}async function B(){try{const u=await fetch("/api/v1/logs/journal/units");if(!u.ok){f(!1);return}const t=await u.json();f(!!t.available)}catch{f(!1)}}function w(){const u=(h.value||"").trim().toLowerCase(),t=u?d.filter(e=>(e.textContent||"").toLowerCase().includes(u)):d;if(t.length===0)k.innerHTML='<div class="logs-loading" style="color: var(--muted); text-align: center; padding: 40px;">No entries'+(u?` matching &quot;${m(u)}&quot;`:"")+"</div>";else{const e=t.map(n=>{const r=n.timestamp?m(n.timestamp):"\u2014",a=m(n.textContent);return`<div class="jd-line" style="padding: 1px 0; line-height: 1.4; color: #d4d4d4;"><span style="color: var(--muted); margin-right: 8px;">${r}</span>${a}</div>`}).join("");k.innerHTML=e,k.scrollHeight-k.scrollTop-k.clientHeight<80&&(k.scrollTop=k.scrollHeight)}M.textContent=`${d.length} entries`,T.textContent=u?`${t.length} of ${d.length} shown`:`${d.length} shown`}async function L(){if(!b)return;p();const u=R.value;if(!u)return;const t=Math.max(1,Math.min(5e3,Number(P.value)||200)),e=(h.value||"").trim();k.innerHTML='<div class="logs-loading" style="color: var(--muted); text-align: center; padding: 40px;">Loading\u2026</div>';try{const s=new URL("/api/v1/logs/journal",window.location.origin);s.searchParams.set("unit",u),s.searchParams.set("tail",String(t)),e&&s.searchParams.set("search",e);const n=await fetch(s.toString()),r=await n.json();if(!n.ok||!r.success){k.innerHTML='<div class="logs-loading" style="color: var(--bad-fg, #ef4444); text-align: center; padding: 40px;">Failed: '+m(r&&r.error||"HTTP "+n.status)+"</div>";return}C.textContent=u,d=(r.entries||[]).map(a=>({timestamp:a.timestamp,unit:a.unit,textContent:a.text||""})),z.style.display="none",w()}catch(s){k.innerHTML='<div class="logs-loading" style="color: var(--bad-fg, #ef4444); text-align: center; padding: 40px;">Error: '+m(s.message)+"</div>"}}function o(){if(!b)return;p();const u=R.value;if(!u)return;const t=(h.value||"").trim();C.textContent=u,D.textContent="\u23F8 Stop",D.classList.add("streaming"),H.textContent="streaming",H.style.color="var(--ok-fg, #4ade80)",d=[],w(),z.style.display="none";const e=new URL("/api/v1/logs/journal/stream",window.location.origin);e.searchParams.set("unit",u),t&&e.searchParams.set("search",t),S=new EventSource(e.toString()),S.onmessage=s=>{try{const n=JSON.parse(s.data);if(n.error){/stream (exceeded|line cap)/.test(n.error)&&(z.style.display="",p()),k.innerHTML+='<div class="jd-line" style="color: var(--bad-fg, #ef4444); padding: 4px 0;">\u26A0 '+m(n.error)+"</div>",k.scrollTop=k.scrollHeight;return}d.push({timestamp:n.timestamp,unit:n.unit||u,textContent:n.text||""}),d.length>5e3&&(d=d.slice(d.length-5e3),z.style.display=""),w()}catch{}},S.onerror=()=>{},v=!0}function p(){if(v=!1,S){try{S.close()}catch{}S=null}D.textContent="\u25B6 Stream",D.classList.remove("streaming"),H.textContent="disconnected",H.style.color="var(--muted)"}function l(){p(),E.classList.remove("show")}A.addEventListener("click",L),D.addEventListener("click",()=>v?p():o()),j.addEventListener("click",()=>{h.value="",w()}),h.addEventListener("input",()=>{clearTimeout(O),O=setTimeout(w,200)}),h.addEventListener("keydown",u=>{u.key==="Escape"&&(h.value="",w())}),g.addEventListener("click",l),$.addEventListener("click",l),E.addEventListener("click",u=>{u.target===E&&l()}),document.addEventListener("keydown",u=>{u.key==="Escape"&&E.classList.contains("show")&&l()}),R.addEventListener("change",()=>{d.length>0&&L()});function y(){E.classList.add("show"),B()}window.openJournaldModal=y,document.getElementById("view-journald-logs")?.addEventListener("click",y)})(),(function(){injectModal("snapshot-modal",`<div id="snapshot-modal" class="weather-modal">
+  `);const E=document.getElementById("journald-modal"),j=document.getElementById("jd-unit-select"),h=document.getElementById("jd-search"),P=document.getElementById("jd-tail"),A=document.getElementById("jd-refresh"),D=document.getElementById("jd-stream"),R=document.getElementById("jd-clear-search"),y=document.getElementById("jd-close"),$=document.getElementById("jd-close-btn"),k=document.getElementById("jd-content"),H=document.getElementById("jd-line-count"),T=document.getElementById("jd-filter-count"),z=document.getElementById("jd-overflow"),C=document.getElementById("jd-unit-display"),M=document.getElementById("jd-stream-state");let b=!1,d=[],v=!1,S=null,O=null;function m(p){const t=document.createElement("div");return t.textContent=String(p),t.innerHTML}function f(p){b=p,j.innerHTML="",x.forEach(t=>{const e=document.createElement("option");e.value=t.unit,e.textContent=t.label+" ("+t.unit+")",j.appendChild(e)}),j.disabled=!p,p?(A.disabled=!1,D.disabled=!1):(k.innerHTML='<div class="logs-loading" style="color: var(--muted); text-align: center; padding: 40px;">journald bind-mount not available in this container.<br/><small>Requires <code>/var/log/journal</code> + <code>/usr/bin/journalctl</code> mounted (start.sh).</small></div>',A.disabled=!0,D.disabled=!0)}async function B(){try{const p=await fetch("/api/v1/logs/journal/units");if(!p.ok){f(!1);return}const t=await p.json();f(!!t.available)}catch{f(!1)}}function w(){const p=(h.value||"").trim().toLowerCase(),t=p?d.filter(e=>(e.textContent||"").toLowerCase().includes(p)):d;if(t.length===0)k.innerHTML='<div class="logs-loading" style="color: var(--muted); text-align: center; padding: 40px;">No entries'+(p?` matching &quot;${m(p)}&quot;`:"")+"</div>";else{const e=t.map(n=>{const r=n.timestamp?m(n.timestamp):"\u2014",a=m(n.textContent);return`<div class="jd-line" style="padding: 1px 0; line-height: 1.4; color: #d4d4d4;"><span style="color: var(--muted); margin-right: 8px;">${r}</span>${a}</div>`}).join("");k.innerHTML=e,k.scrollHeight-k.scrollTop-k.clientHeight<80&&(k.scrollTop=k.scrollHeight)}H.textContent=`${d.length} entries`,T.textContent=p?`${t.length} of ${d.length} shown`:`${d.length} shown`}async function L(){if(!b)return;u();const p=j.value;if(!p)return;const t=Math.max(1,Math.min(5e3,Number(P.value)||200)),e=(h.value||"").trim();k.innerHTML='<div class="logs-loading" style="color: var(--muted); text-align: center; padding: 40px;">Loading\u2026</div>';try{const s=new URL("/api/v1/logs/journal",window.location.origin);s.searchParams.set("unit",p),s.searchParams.set("tail",String(t)),e&&s.searchParams.set("search",e);const n=await fetch(s.toString()),r=await n.json();if(!n.ok||!r.success){k.innerHTML='<div class="logs-loading" style="color: var(--bad-fg, #ef4444); text-align: center; padding: 40px;">Failed: '+m(r&&r.error||"HTTP "+n.status)+"</div>";return}C.textContent=p,d=(r.entries||[]).map(a=>({timestamp:a.timestamp,unit:a.unit,textContent:a.text||""})),z.style.display="none",w()}catch(s){k.innerHTML='<div class="logs-loading" style="color: var(--bad-fg, #ef4444); text-align: center; padding: 40px;">Error: '+m(s.message)+"</div>"}}function o(){if(!b)return;u();const p=j.value;if(!p)return;const t=(h.value||"").trim();C.textContent=p,D.textContent="\u23F8 Stop",D.classList.add("streaming"),M.textContent="streaming",M.style.color="var(--ok-fg, #4ade80)",d=[],w(),z.style.display="none";const e=new URL("/api/v1/logs/journal/stream",window.location.origin);e.searchParams.set("unit",p),t&&e.searchParams.set("search",t),S=new EventSource(e.toString()),S.onmessage=s=>{try{const n=JSON.parse(s.data);if(n.error){/stream (exceeded|line cap)/.test(n.error)&&(z.style.display="",u()),k.innerHTML+='<div class="jd-line" style="color: var(--bad-fg, #ef4444); padding: 4px 0;">\u26A0 '+m(n.error)+"</div>",k.scrollTop=k.scrollHeight;return}d.push({timestamp:n.timestamp,unit:n.unit||p,textContent:n.text||""}),d.length>5e3&&(d=d.slice(d.length-5e3),z.style.display=""),w()}catch{}},S.onerror=()=>{},v=!0}function u(){if(v=!1,S){try{S.close()}catch{}S=null}D.textContent="\u25B6 Stream",D.classList.remove("streaming"),M.textContent="disconnected",M.style.color="var(--muted)"}function l(){u(),E.classList.remove("show")}A.addEventListener("click",L),D.addEventListener("click",()=>v?u():o()),R.addEventListener("click",()=>{h.value="",w()}),h.addEventListener("input",()=>{clearTimeout(O),O=setTimeout(w,200)}),h.addEventListener("keydown",p=>{p.key==="Escape"&&(h.value="",w())}),y.addEventListener("click",l),$.addEventListener("click",l),E.addEventListener("click",p=>{p.target===E&&l()}),document.addEventListener("keydown",p=>{p.key==="Escape"&&E.classList.contains("show")&&l()}),j.addEventListener("change",()=>{d.length>0&&L()});function g(){E.classList.add("show"),B()}window.openJournaldModal=g,document.getElementById("view-journald-logs")?.addEventListener("click",g)})(),(function(){injectModal("snapshot-modal",`<div id="snapshot-modal" class="weather-modal">
     <div class="weather-modal-content" style="min-width: 700px; max-width: 850px;">
       <h3>\u{1F4BE} Container Snapshots</h3>
       <p class="modal-subtitle">
@@ -752,7 +752,7 @@ Try refreshing in a moment if you see a certificate error.`,"warning",1e4),!1}};
         <button id="snapshot-close">Close</button>
       </div>
     </div>
-  </div>`);const x=document.getElementById("snapshot-modal"),E=document.getElementById("snapshot-btn"),R=document.getElementById("snapshot-close"),h=document.getElementById("snapshot-container-select"),P=document.getElementById("snapshot-details"),A=document.getElementById("snapshot-create-btn"),D=document.getElementById("snapshot-create-status");let j=null;async function g(){try{const C=await(await fetch("/api/v1/containers")).json();if(!C.success||!C.containers)return;h.innerHTML='<option value="">-- Select a container --</option>';for(const H of C.containers){const b=document.createElement("option");b.value=H.id,b.textContent=`${H.name||H.id} (${H.image||"unknown"})`,b.dataset.name=H.name,b.dataset.image=H.image,b.dataset.status=H.status,b.dataset.created=H.created,h.appendChild(b)}}catch(z){console.error("Failed to load containers:",z)}}function $(z){if(!z||!z.value){P.style.display="none",j=null;return}j=z.value,document.getElementById("snapshot-image").textContent=z.dataset.image||"-",document.getElementById("snapshot-status").textContent=z.dataset.status||"-",document.getElementById("snapshot-created").textContent=z.dataset.created?new Date(z.dataset.created*1e3).toLocaleString():"-",document.getElementById("snapshot-id").textContent=z.value.substring(0,12),P.style.display=""}async function k(){if(!j){D.textContent="Please select a container first",D.style.color="var(--bad-fg)";return}const z=document.getElementById("snapshot-name").value.trim();if(!z){D.textContent="Please enter a snapshot name",D.style.color="var(--bad-fg)";return}const C=document.getElementById("snapshot-leave-running").checked;A.disabled=!0,A.textContent="Creating...",D.textContent="";try{const b=await(await fetch(`/api/v1/containers/${encodeURIComponent(j)}/checkpoint`,{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify({name:z,leaveRunning:C})})).json();b.success?(D.textContent=`\u2713 Snapshot "${z}" created successfully`,D.style.color="var(--ok-fg)",document.getElementById("snapshot-name").value=""):(D.textContent=`\u2717 Failed: ${b.error||"Unknown error"}`,D.style.color="var(--bad-fg)")}catch(H){D.textContent=`\u2717 Error: ${H.message}`,D.style.color="var(--bad-fg)"}finally{A.disabled=!1,A.textContent="\u{1F4BE} Create Snapshot"}}function M(){x.classList.add("show"),g()}function T(){x.classList.remove("show"),P.style.display="none",j=null,h.selectedIndex=0}E?.addEventListener("click",M),R?.addEventListener("click",T),wireModal(x,R),h?.addEventListener("change",z=>{const C=h.options[h.selectedIndex];$(C)}),A?.addEventListener("click",k),x?.querySelectorAll(".panel-tab").forEach(z=>{z.addEventListener("click",()=>{x.querySelectorAll(".panel-tab").forEach(C=>C.classList.remove("active")),x.querySelectorAll(".panel-section").forEach(C=>C.classList.remove("active")),z.classList.add("active"),x.querySelector(`#${z.dataset.panel}`).classList.add("active")})})})(),(function(){injectModal("arr-setup-modal",`<div id="arr-setup-modal" class="weather-modal">
+  </div>`);const x=document.getElementById("snapshot-modal"),E=document.getElementById("snapshot-btn"),j=document.getElementById("snapshot-close"),h=document.getElementById("snapshot-container-select"),P=document.getElementById("snapshot-details"),A=document.getElementById("snapshot-create-btn"),D=document.getElementById("snapshot-create-status");let R=null;async function y(){try{const C=await(await fetch("/api/v1/containers")).json();if(!C.success||!C.containers)return;h.innerHTML='<option value="">-- Select a container --</option>';for(const M of C.containers){const b=document.createElement("option");b.value=M.id,b.textContent=`${M.name||M.id} (${M.image||"unknown"})`,b.dataset.name=M.name,b.dataset.image=M.image,b.dataset.status=M.status,b.dataset.created=M.created,h.appendChild(b)}}catch(z){console.error("Failed to load containers:",z)}}function $(z){if(!z||!z.value){P.style.display="none",R=null;return}R=z.value,document.getElementById("snapshot-image").textContent=z.dataset.image||"-",document.getElementById("snapshot-status").textContent=z.dataset.status||"-",document.getElementById("snapshot-created").textContent=z.dataset.created?new Date(z.dataset.created*1e3).toLocaleString():"-",document.getElementById("snapshot-id").textContent=z.value.substring(0,12),P.style.display=""}async function k(){if(!R){D.textContent="Please select a container first",D.style.color="var(--bad-fg)";return}const z=document.getElementById("snapshot-name").value.trim();if(!z){D.textContent="Please enter a snapshot name",D.style.color="var(--bad-fg)";return}const C=document.getElementById("snapshot-leave-running").checked;A.disabled=!0,A.textContent="Creating...",D.textContent="";try{const b=await(await fetch(`/api/v1/containers/${encodeURIComponent(R)}/checkpoint`,{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify({name:z,leaveRunning:C})})).json();b.success?(D.textContent=`\u2713 Snapshot "${z}" created successfully`,D.style.color="var(--ok-fg)",document.getElementById("snapshot-name").value=""):(D.textContent=`\u2717 Failed: ${b.error||"Unknown error"}`,D.style.color="var(--bad-fg)")}catch(M){D.textContent=`\u2717 Error: ${M.message}`,D.style.color="var(--bad-fg)"}finally{A.disabled=!1,A.textContent="\u{1F4BE} Create Snapshot"}}function H(){x.classList.add("show"),y()}function T(){x.classList.remove("show"),P.style.display="none",R=null,h.selectedIndex=0}E?.addEventListener("click",H),j?.addEventListener("click",T),wireModal(x,j),h?.addEventListener("change",z=>{const C=h.options[h.selectedIndex];$(C)}),A?.addEventListener("click",k),x?.querySelectorAll(".panel-tab").forEach(z=>{z.addEventListener("click",()=>{x.querySelectorAll(".panel-tab").forEach(C=>C.classList.remove("active")),x.querySelectorAll(".panel-section").forEach(C=>C.classList.remove("active")),z.classList.add("active"),x.querySelector(`#${z.dataset.panel}`).classList.add("active")})})})(),(function(){injectModal("arr-setup-modal",`<div id="arr-setup-modal" class="weather-modal">
     <div class="weather-modal-content" style="min-width: 600px; max-width: 720px;">
       <h3>\u{1F3AC} Smart Arr Connect</h3>
       <p style="color: var(--muted); margin: 0 0 16px; font-size: 0.9rem;">
@@ -831,10 +831,10 @@ Try refreshing in a moment if you see a certificate error.`,"warning",1e4),!1}};
         <button id="arr-setup-cancel">Close</button>
       </div>
     </div>
-  </div>`);const x=document.getElementById("arr-setup-modal"),E=document.getElementById("arr-setup-btn"),R=document.getElementById("arr-setup-cancel"),h=document.getElementById("smart-connect-btn"),P=document.getElementById("smart-phase-detect"),A=document.getElementById("smart-phase-credentials"),D=document.getElementById("smart-phase-progress"),j=document.getElementById("smart-phase-results"),g=document.getElementById("smart-detect-results"),$=document.getElementById("smart-credential-inputs"),k=document.getElementById("smart-progress-steps"),M=document.getElementById("smart-results-content"),T=document.getElementById("smart-plex-libraries"),z=document.getElementById("smart-retry-btn");let C=null;const H={plex:"\u{1F3AC}",radarr:"\u{1F3AC}",sonarr:"\u{1F4FA}",prowlarr:"\u{1F50D}",seerr:"\u{1F4CB}"},b={plex:"Plex",radarr:"Radarr (Movies)",sonarr:"Sonarr (TV)",prowlarr:"Prowlarr (Indexers)",seerr:"Seerr"};function d(w){P.style.display=w==="detect"?"block":"none",A.style.display=w==="credentials"?"block":"none",D.style.display=w==="progress"?"block":"none",j.style.display=w==="results"?"block":"none"}function v(w){const L={connected:{bg:"var(--ok-fg)",icon:"&#10003;",text:"Connected"},needs_key:{bg:"#f39c12",icon:"&#128273;",text:"Needs API Key"},not_found:{bg:"var(--muted)",icon:"&mdash;",text:"Not Found"},error:{bg:"var(--bad-fg)",icon:"&#10007;",text:"Error"}},o=L[w]||L.not_found;return`<span style="display: inline-flex; align-items: center; gap: 4px; padding: 2px 8px; border-radius: 4px; font-size: 0.75rem; background: color-mix(in srgb, ${o.bg} 20%, transparent); color: ${o.bg};">${o.icon} ${o.text}</span>`}async function S(){d("detect"),g.style.display="none";try{if(C=await(await fetch("/api/v1/arr/smart-detect")).json(),!C.success){g.innerHTML=`<div style="padding: 12px; color: var(--bad-fg);">Detection failed: ${escapeHtml(C.error)}</div>`,g.style.display="block";return}let L='<div style="display: flex; flex-direction: column; gap: 8px;">';for(const[p,l]of Object.entries(C.services)){const y=H[p]||"\u{1F4E6}",u=b[p]||p,t=l.source?`<span style="font-size: 0.7rem; color: var(--muted); padding: 1px 6px; background: var(--card-bg); border-radius: 3px;">${escapeHtml(l.source)}</span>`:"",e=l.version?`<span style="font-size: 0.7rem; color: var(--muted);">v${escapeHtml(l.version)}</span>`:"",s=(l.hasApiKey||l.hasToken)&&l.status==="connected"?'<span style="font-size: 0.7rem; color: var(--ok-fg);">Key saved</span>':"";L+=`<div style="display: flex; align-items: center; gap: 10px; padding: 10px 12px; background: var(--card-base); border-radius: 8px; border: 1px solid var(--border);">
-          <span style="font-size: 1.1rem;">${y}</span>
+  </div>`);const x=document.getElementById("arr-setup-modal"),E=document.getElementById("arr-setup-btn"),j=document.getElementById("arr-setup-cancel"),h=document.getElementById("smart-connect-btn"),P=document.getElementById("smart-phase-detect"),A=document.getElementById("smart-phase-credentials"),D=document.getElementById("smart-phase-progress"),R=document.getElementById("smart-phase-results"),y=document.getElementById("smart-detect-results"),$=document.getElementById("smart-credential-inputs"),k=document.getElementById("smart-progress-steps"),H=document.getElementById("smart-results-content"),T=document.getElementById("smart-plex-libraries"),z=document.getElementById("smart-retry-btn");let C=null;const M={plex:"\u{1F3AC}",radarr:"\u{1F3AC}",sonarr:"\u{1F4FA}",prowlarr:"\u{1F50D}",seerr:"\u{1F4CB}"},b={plex:"Plex",radarr:"Radarr (Movies)",sonarr:"Sonarr (TV)",prowlarr:"Prowlarr (Indexers)",seerr:"Seerr"};function d(w){P.style.display=w==="detect"?"block":"none",A.style.display=w==="credentials"?"block":"none",D.style.display=w==="progress"?"block":"none",R.style.display=w==="results"?"block":"none"}function v(w){const L={connected:{bg:"var(--ok-fg)",icon:"&#10003;",text:"Connected"},needs_key:{bg:"#f39c12",icon:"&#128273;",text:"Needs API Key"},not_found:{bg:"var(--muted)",icon:"&mdash;",text:"Not Found"},error:{bg:"var(--bad-fg)",icon:"&#10007;",text:"Error"}},o=L[w]||L.not_found;return`<span style="display: inline-flex; align-items: center; gap: 4px; padding: 2px 8px; border-radius: 4px; font-size: 0.75rem; background: color-mix(in srgb, ${o.bg} 20%, transparent); color: ${o.bg};">${o.icon} ${o.text}</span>`}async function S(){d("detect"),y.style.display="none";try{if(C=await(await fetch("/api/v1/arr/smart-detect")).json(),!C.success){y.innerHTML=`<div style="padding: 12px; color: var(--bad-fg);">Detection failed: ${escapeHtml(C.error)}</div>`,y.style.display="block";return}let L='<div style="display: flex; flex-direction: column; gap: 8px;">';for(const[u,l]of Object.entries(C.services)){const g=M[u]||"\u{1F4E6}",p=b[u]||u,t=l.source?`<span style="font-size: 0.7rem; color: var(--muted); padding: 1px 6px; background: var(--card-bg); border-radius: 3px;">${escapeHtml(l.source)}</span>`:"",e=l.version?`<span style="font-size: 0.7rem; color: var(--muted);">v${escapeHtml(l.version)}</span>`:"",s=(l.hasApiKey||l.hasToken)&&l.status==="connected"?'<span style="font-size: 0.7rem; color: var(--ok-fg);">Key saved</span>':"";L+=`<div style="display: flex; align-items: center; gap: 10px; padding: 10px 12px; background: var(--card-base); border-radius: 8px; border: 1px solid var(--border);">
+          <span style="font-size: 1.1rem;">${g}</span>
           <div style="flex: 1;">
-            <div style="font-weight: 500; font-size: 0.9rem;">${u}</div>
+            <div style="font-weight: 500; font-size: 0.9rem;">${p}</div>
             <div style="display: flex; gap: 6px; align-items: center; flex-wrap: wrap;">
               ${t} ${e} ${s}
             </div>
@@ -843,61 +843,61 @@ Try refreshing in a moment if you see a certificate error.`,"warning",1e4),!1}};
         </div>`}L+="</div>";const o=C.summary;L+=`<div style="margin-top: 12px; padding: 10px; background: color-mix(in srgb, var(--accent) 8%, transparent); border-radius: 8px; font-size: 0.85rem;">
         ${escapeHtml(String(o.fullyConnected))}/${escapeHtml(String(o.totalDetected+(5-o.totalDetected)))} services detected &middot;
         ${escapeHtml(String(o.fullyConnected))} connected${o.needsApiKey>0?` &middot; <strong>${escapeHtml(String(o.needsApiKey))} needs API key</strong>`:""}
-      </div>`,g.innerHTML=L,g.style.display="block",O(C),setTimeout(()=>{d("credentials")},800)}catch(w){g.innerHTML=`<div style="padding: 12px; color: var(--bad-fg);">Error: ${escapeHtml(w.message)}</div>`,g.style.display="block"}}function O(w){let L="";const o=w.services,p=["radarr","sonarr","prowlarr"];for(const u of p){const t=o[u];if(!t||t.status==="not_found"&&!t.url)continue;const e=H[u],s=b[u],n=t.status==="connected";L+=`<div style="margin-bottom: 10px; padding: 12px; background: var(--card-base); border-radius: 8px; border: 1px solid ${n?"var(--ok-fg)":"var(--border)"};">
+      </div>`,y.innerHTML=L,y.style.display="block",O(C),setTimeout(()=>{d("credentials")},800)}catch(w){y.innerHTML=`<div style="padding: 12px; color: var(--bad-fg);">Error: ${escapeHtml(w.message)}</div>`,y.style.display="block"}}function O(w){let L="";const o=w.services,u=["radarr","sonarr","prowlarr"];for(const p of u){const t=o[p];if(!t||t.status==="not_found"&&!t.url)continue;const e=M[p],s=b[p],n=t.status==="connected";L+=`<div style="margin-bottom: 10px; padding: 12px; background: var(--card-base); border-radius: 8px; border: 1px solid ${n?"var(--ok-fg)":"var(--border)"};">
         <div style="display: flex; align-items: center; gap: 8px; margin-bottom: 8px;">
           <span style="font-size: 1.1rem;">${e}</span>
           <span style="font-weight: 500;">${s}</span>
-          <span id="smart-${u}-status" style="margin-left: auto; font-size: 0.75rem;">
+          <span id="smart-${p}-status" style="margin-left: auto; font-size: 0.75rem;">
             ${n?'<span style="color: var(--ok-fg);">&#10003; Connected</span>':""}
           </span>
         </div>
         <div style="display: grid; grid-template-columns: 2fr 1fr; gap: 8px;">
           <div>
             <label style="font-size: 0.75rem; color: var(--muted);">URL:</label>
-            <input type="text" id="smart-${u}-url" value="${escapeHtml(t.url||"")}" placeholder="https://seedbox.com/${u}/"
+            <input type="text" id="smart-${p}-url" value="${escapeHtml(t.url||"")}" placeholder="https://seedbox.com/${p}/"
                    style="width: 100%; font-size: 0.85rem; padding: 6px 8px; background: var(--card-bg); color: var(--fg); border: 1px solid var(--border); border-radius: 4px;" />
           </div>
           <div>
             <label style="font-size: 0.75rem; color: var(--muted);">API Key:</label>
-            <input type="password" id="smart-${u}-key" placeholder="${n?"(saved)":"Paste API key"}"
+            <input type="password" id="smart-${p}-key" placeholder="${n?"(saved)":"Paste API key"}"
                    style="width: 100%; font-size: 0.85rem; padding: 6px 8px; background: var(--card-bg); color: var(--fg); border: 1px solid var(--border); border-radius: 4px;" />
           </div>
         </div>
-        <button onclick="smartTestConnection('${u}')" style="margin-top: 8px; padding: 4px 12px; font-size: 0.75rem; cursor: pointer;">Test</button>
-      </div>`}const l=o.plex;if(l){const u=l.status==="connected";L+=`<div style="padding: 10px 12px; background: var(--card-base); border-radius: 8px; border: 1px solid ${u?"var(--ok-fg)":"var(--border)"}; margin-bottom: 10px;">
+        <button onclick="smartTestConnection('${p}')" style="margin-top: 8px; padding: 4px 12px; font-size: 0.75rem; cursor: pointer;">Test</button>
+      </div>`}const l=o.plex;if(l){const p=l.status==="connected";L+=`<div style="padding: 10px 12px; background: var(--card-base); border-radius: 8px; border: 1px solid ${p?"var(--ok-fg)":"var(--border)"}; margin-bottom: 10px;">
         <div style="display: flex; align-items: center; gap: 8px;">
           <span style="font-size: 1.1rem;">\u{1F3AC}</span>
           <span style="font-weight: 500;">Plex</span>
           ${v(l.status)}
           <span style="margin-left: auto; font-size: 0.75rem; color: var(--muted);">${escapeHtml(l.source||"")}</span>
         </div>
-      </div>`}const y=o.seerr;if(y){const u=y.status==="connected";let t="";if(y.configuredServices){const e=y.configuredServices;t=`<div style="font-size: 0.75rem; color: var(--muted); margin-top: 4px;">
+      </div>`}const g=o.seerr;if(g){const p=g.status==="connected";let t="";if(g.configuredServices){const e=g.configuredServices;t=`<div style="font-size: 0.75rem; color: var(--muted); margin-top: 4px;">
           Configured: ${e.radarr?"&#10003; Radarr":"&#10007; Radarr"} &middot;
           ${e.sonarr?"&#10003; Sonarr":"&#10007; Sonarr"} &middot;
           ${e.plex?"&#10003; Plex":"&#10007; Plex"}
-        </div>`}L+=`<div style="padding: 10px 12px; background: var(--card-base); border-radius: 8px; border: 1px solid ${u?"var(--ok-fg)":"var(--border)"};">
+        </div>`}L+=`<div style="padding: 10px 12px; background: var(--card-base); border-radius: 8px; border: 1px solid ${p?"var(--ok-fg)":"var(--border)"};">
         <div style="display: flex; align-items: center; gap: 8px;">
           <span style="font-size: 1.1rem;">\u{1F4CB}</span>
           <span style="font-weight: 500;">Seerr</span>
-          ${v(y.status)}
+          ${v(g.status)}
         </div>
         ${t}
-      </div>`}$.innerHTML=L}window.smartTestConnection=async function(w){const L=document.getElementById(`smart-${w}-url`),o=document.getElementById(`smart-${w}-key`),p=document.getElementById(`smart-${w}-status`),l=L?.value.trim(),y=o?.value.trim();if(!l||!y){p.innerHTML='<span style="color: var(--bad-fg);">Enter URL and API key</span>';return}p.innerHTML='<span class="brand-spinner"></span>';try{const t=await(await secureFetch("/api/v1/arr/test-connection",{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify({service:w,url:l,apiKey:y})})).json();t.success?p.innerHTML=`<span style="color: var(--ok-fg);">&#10003; ${escapeHtml(t.appName||"Connected")} v${escapeHtml(t.version||"")}</span>`:p.innerHTML=`<span style="color: var(--bad-fg);">&#10007; ${escapeHtml(t.error)}</span>`}catch(u){p.innerHTML=`<span style="color: var(--bad-fg);">&#10007; ${escapeHtml(u.message)}</span>`}};async function m(){d("progress"),k.innerHTML='<div style="text-align: center; padding: 20px;"><span class="brand-spinner"></span><div style="color: var(--muted); margin-top: 8px;">Connecting services...</div></div>';const w={};for(const o of["radarr","sonarr","prowlarr"]){const p=document.getElementById(`smart-${o}-url`)?.value.trim(),l=document.getElementById(`smart-${o}-key`)?.value.trim();l&&p?w[o]={apiKey:l,url:p}:l&&(w[o]={apiKey:l})}const L={services:Object.keys(w).length>0?w:void 0,configurePlex:document.getElementById("smart-opt-plex")?.checked,configureProwlarr:document.getElementById("smart-opt-prowlarr")?.checked,configureSeerr:document.getElementById("smart-opt-seerr")?.checked,saveCredentials:document.getElementById("smart-opt-save")?.checked};try{const p=await(await secureFetch("/api/v1/arr/smart-connect",{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify(L)})).json();let l="";for(const y of p.steps||[]){const u=y.status==="success"?'<span style="color: var(--ok-fg);">&#10003;</span>':'<span style="color: var(--bad-fg);">&#10007;</span>',t=y.status==="success"?"var(--muted)":"var(--bad-fg)";l+=`<div style="display: flex; align-items: center; gap: 8px; padding: 6px 10px; background: var(--card-base); border-radius: 6px; font-size: 0.85rem;">
-          ${u}
-          <span>${escapeHtml(y.step)}</span>
-          <span style="margin-left: auto; font-size: 0.75rem; color: ${t};">${escapeHtml(y.details||"")}</span>
-        </div>`}k.innerHTML=l,setTimeout(()=>f(p),500)}catch(o){k.innerHTML=`<div style="padding: 12px; color: var(--bad-fg);">Connection error: ${escapeHtml(o.message)}</div>`}}function f(w){d("results");const L=w.summary||{},o=L.failed===0&&L.succeeded>0,p=o?"var(--ok-fg)":"#f39c12",l=o?"&#10003;":"&#9888;",y=o?"All Connected!":`${escapeHtml(String(L.succeeded))}/${escapeHtml(String(L.totalSteps))} Steps Succeeded`;let u=`<div style="text-align: center; padding: 16px; background: color-mix(in srgb, ${p} 12%, transparent); border-radius: 10px; border: 1px solid ${p}; margin-bottom: 12px;">
-      <div style="font-size: 1.5rem; color: ${p};">${l}</div>
-      <div style="font-size: 1.1rem; font-weight: 600; color: ${p};">${y}</div>
+      </div>`}$.innerHTML=L}window.smartTestConnection=async function(w){const L=document.getElementById(`smart-${w}-url`),o=document.getElementById(`smart-${w}-key`),u=document.getElementById(`smart-${w}-status`),l=L?.value.trim(),g=o?.value.trim();if(!l||!g){u.innerHTML='<span style="color: var(--bad-fg);">Enter URL and API key</span>';return}u.innerHTML='<span class="brand-spinner"></span>';try{const t=await(await secureFetch("/api/v1/arr/test-connection",{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify({service:w,url:l,apiKey:g})})).json();t.success?u.innerHTML=`<span style="color: var(--ok-fg);">&#10003; ${escapeHtml(t.appName||"Connected")} v${escapeHtml(t.version||"")}</span>`:u.innerHTML=`<span style="color: var(--bad-fg);">&#10007; ${escapeHtml(t.error)}</span>`}catch(p){u.innerHTML=`<span style="color: var(--bad-fg);">&#10007; ${escapeHtml(p.message)}</span>`}};async function m(){d("progress"),k.innerHTML='<div style="text-align: center; padding: 20px;"><span class="brand-spinner"></span><div style="color: var(--muted); margin-top: 8px;">Connecting services...</div></div>';const w={};for(const o of["radarr","sonarr","prowlarr"]){const u=document.getElementById(`smart-${o}-url`)?.value.trim(),l=document.getElementById(`smart-${o}-key`)?.value.trim();l&&u?w[o]={apiKey:l,url:u}:l&&(w[o]={apiKey:l})}const L={services:Object.keys(w).length>0?w:void 0,configurePlex:document.getElementById("smart-opt-plex")?.checked,configureProwlarr:document.getElementById("smart-opt-prowlarr")?.checked,configureSeerr:document.getElementById("smart-opt-seerr")?.checked,saveCredentials:document.getElementById("smart-opt-save")?.checked};try{const u=await(await secureFetch("/api/v1/arr/smart-connect",{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify(L)})).json();let l="";for(const g of u.steps||[]){const p=g.status==="success"?'<span style="color: var(--ok-fg);">&#10003;</span>':'<span style="color: var(--bad-fg);">&#10007;</span>',t=g.status==="success"?"var(--muted)":"var(--bad-fg)";l+=`<div style="display: flex; align-items: center; gap: 8px; padding: 6px 10px; background: var(--card-base); border-radius: 6px; font-size: 0.85rem;">
+          ${p}
+          <span>${escapeHtml(g.step)}</span>
+          <span style="margin-left: auto; font-size: 0.75rem; color: ${t};">${escapeHtml(g.details||"")}</span>
+        </div>`}k.innerHTML=l,setTimeout(()=>f(u),500)}catch(o){k.innerHTML=`<div style="padding: 12px; color: var(--bad-fg);">Connection error: ${escapeHtml(o.message)}</div>`}}function f(w){d("results");const L=w.summary||{},o=L.failed===0&&L.succeeded>0,u=o?"var(--ok-fg)":"#f39c12",l=o?"&#10003;":"&#9888;",g=o?"All Connected!":`${escapeHtml(String(L.succeeded))}/${escapeHtml(String(L.totalSteps))} Steps Succeeded`;let p=`<div style="text-align: center; padding: 16px; background: color-mix(in srgb, ${u} 12%, transparent); border-radius: 10px; border: 1px solid ${u}; margin-bottom: 12px;">
+      <div style="font-size: 1.5rem; color: ${u};">${l}</div>
+      <div style="font-size: 1.1rem; font-weight: 600; color: ${u};">${g}</div>
       <div style="font-size: 0.85rem; color: var(--muted); margin-top: 4px;">${escapeHtml(String(L.succeeded))} succeeded, ${escapeHtml(String(L.failed))} failed</div>
-    </div>`;u+='<div style="display: flex; flex-direction: column; gap: 4px;">';for(const t of w.steps||[]){const e=t.status==="success"?'<span style="color: var(--ok-fg);">&#10003;</span>':'<span style="color: var(--bad-fg);">&#10007;</span>';u+=`<div style="display: flex; align-items: center; gap: 8px; padding: 4px 8px; font-size: 0.8rem;">
+    </div>`;p+='<div style="display: flex; flex-direction: column; gap: 4px;">';for(const t of w.steps||[]){const e=t.status==="success"?'<span style="color: var(--ok-fg);">&#10003;</span>':'<span style="color: var(--bad-fg);">&#10007;</span>';p+=`<div style="display: flex; align-items: center; gap: 8px; padding: 4px 8px; font-size: 0.8rem;">
         ${e} ${escapeHtml(t.step)} <span style="margin-left: auto; color: var(--muted); font-size: 0.75rem;">${escapeHtml(t.details||"")}</span>
-      </div>`}u+="</div>",M.innerHTML=u,z.style.display=L.failed>0?"block":"none",w.steps?.some(t=>t.step.includes("Plex")&&t.status==="success")&&B()}async function B(){try{const L=await(await fetch("/api/v1/plex/libraries")).json();if(L.success&&L.libraries?.length>0){let o=`<div style="padding: 12px; background: var(--card-base); border-radius: 8px; border: 1px solid var(--border);">
+      </div>`}p+="</div>",H.innerHTML=p,z.style.display=L.failed>0?"block":"none",w.steps?.some(t=>t.step.includes("Plex")&&t.status==="success")&&B()}async function B(){try{const L=await(await fetch("/api/v1/plex/libraries")).json();if(L.success&&L.libraries?.length>0){let o=`<div style="padding: 12px; background: var(--card-base); border-radius: 8px; border: 1px solid var(--border);">
           <h4 style="margin: 0 0 8px; font-size: 0.85rem; color: var(--accent);">\u{1F3AC} ${escapeHtml(L.serverName)} Libraries</h4>
-          <div style="display: flex; flex-wrap: wrap; gap: 8px;">`;for(const p of L.libraries){const l=p.type==="movie"?"\u{1F3AC}":p.type==="show"?"\u{1F4FA}":"\u{1F3B5}";o+=`<div style="padding: 8px 12px; background: var(--card-bg); border-radius: 6px; font-size: 0.85rem;">
-            ${l} <strong>${escapeHtml(p.title)}</strong>
-            <span style="color: var(--muted); font-size: 0.75rem;">${escapeHtml(String(p.count))} items</span>
-          </div>`}o+="</div></div>",T.innerHTML=o,T.style.display="block"}}catch{}}E?.addEventListener("click",()=>{x.classList.add("show"),T.style.display="none",S()}),wireModal(x,R),h?.addEventListener("click",m),z?.addEventListener("click",m)})(),(function(){const x=new ErrorHandler;injectModal("notifications-modal",`<div id="notifications-modal" class="weather-modal">
+          <div style="display: flex; flex-wrap: wrap; gap: 8px;">`;for(const u of L.libraries){const l=u.type==="movie"?"\u{1F3AC}":u.type==="show"?"\u{1F4FA}":"\u{1F3B5}";o+=`<div style="padding: 8px 12px; background: var(--card-bg); border-radius: 6px; font-size: 0.85rem;">
+            ${l} <strong>${escapeHtml(u.title)}</strong>
+            <span style="color: var(--muted); font-size: 0.75rem;">${escapeHtml(String(u.count))} items</span>
+          </div>`}o+="</div></div>",T.innerHTML=o,T.style.display="block"}}catch{}}E?.addEventListener("click",()=>{x.classList.add("show"),T.style.display="none",S()}),wireModal(x,j),h?.addEventListener("click",m),z?.addEventListener("click",m)})(),(function(){const x=new ErrorHandler;injectModal("notifications-modal",`<div id="notifications-modal" class="weather-modal">
     <div class="weather-modal-content" style="min-width: 550px; max-width: 650px;">
       <h3>\u{1F514} Notification Settings</h3>
 
@@ -1109,15 +1109,15 @@ Try refreshing in a moment if you see a certificate error.`,"warning",1e4),!1}};
         <button id="notifications-save" class="btn-accent">Save Settings</button>
       </div>
     </div>
-  </div>`);const E=document.getElementById("notifications-modal"),R=document.getElementById("manage-notifications"),h=document.getElementById("notifications-save"),P=document.getElementById("notifications-cancel");["discord","telegram","ntfy","email"].forEach(T=>{const z=document.getElementById(`${T}-enabled`),C=document.getElementById(`${T}-config`);z?.addEventListener("change",()=>{C.style.display=z.checked?"block":"none"})});const A=document.getElementById("health-check-enabled"),D=document.getElementById("health-check-config");A?.addEventListener("change",()=>{D.style.opacity=A.checked?"1":"0.5"});async function j(){try{const z=await(await fetch("/api/v1/notifications/config")).json();if(z.success){const C=z.config;document.getElementById("notifications-enabled").checked=C.enabled,document.getElementById("discord-enabled").checked=C.providers?.discord?.enabled||!1,document.getElementById("telegram-enabled").checked=C.providers?.telegram?.enabled||!1,document.getElementById("ntfy-enabled").checked=C.providers?.ntfy?.enabled||!1,document.getElementById("email-enabled").checked=C.providers?.email?.enabled||!1,document.getElementById("discord-config").style.display=C.providers?.discord?.enabled?"block":"none",document.getElementById("telegram-config").style.display=C.providers?.telegram?.enabled?"block":"none",document.getElementById("ntfy-config").style.display=C.providers?.ntfy?.enabled?"block":"none",document.getElementById("email-config").style.display=C.providers?.email?.enabled?"block":"none",C.providers?.ntfy?.serverUrl&&(document.getElementById("ntfy-server").value=C.providers.ntfy.serverUrl),C.providers?.email?.host&&(document.getElementById("email-host").value=C.providers.email.host),C.providers?.email?.from&&(document.getElementById("email-from").value=C.providers.email.from),C.providers?.email?.to&&(document.getElementById("email-to").value=C.providers.email.to),C.providers?.email?.port&&(document.getElementById("email-port").value=C.providers.email.port),C.providers?.email?.secure!==void 0&&(document.getElementById("email-secure").checked=C.providers.email.secure===!0),C.providers?.email?.username&&(document.getElementById("email-user").value=C.providers.email.username);const H=document.getElementById("email-pass");C.providers?.email?.hasPassword?(H.value="",H.placeholder="saved \u2014 leave blank to keep"):H.placeholder="app password",document.getElementById("health-check-enabled").checked=C.healthCheck?.enabled||!1,C.healthCheck?.intervalMinutes&&(document.getElementById("health-check-interval").value=C.healthCheck.intervalMinutes),C.healthCheck?.lastCheck&&(document.getElementById("health-check-status").textContent=`Last check: ${new Date(C.healthCheck.lastCheck).toLocaleString()}`),document.getElementById("event-container-down").checked=C.events?.["container-down"]!==!1,document.getElementById("event-container-up").checked=C.events?.["container-up"]===!0,document.getElementById("event-deploy-success").checked=C.events?.["deploy-success"]!==!1,document.getElementById("event-deploy-failed").checked=C.events?.["deploy-failed"]!==!1,document.getElementById("event-ssl-cert-expiry").checked=C.events?.["ssl-cert-expiry"]!==!1,document.getElementById("event-dns-propagation").checked=C.events?.["dns-propagation"]!==!1,document.getElementById("event-drift-detected").checked=C.events?.["drift-detected"]!==!1,document.getElementById("event-dependency-restart").checked=C.events?.["dependency-restart"]!==!1,document.getElementById("event-recipe-removed").checked=C.events?.["recipe-removed"]!==!1,document.getElementById("event-workflow").checked=C.events?.workflow!==!1,document.getElementById("event-backup-complete").checked=C.events?.["backup-complete"]!==!1,document.getElementById("event-backup-failed").checked=C.events?.["backup-failed"]!==!1,document.getElementById("event-update-available").checked=C.events?.["update-available"]!==!1,document.getElementById("event-resource-alert").checked=C.events?.alert!==!1}}catch(T){x.logError("[Notifications] Load Config",T,{function:"loadConfig"})}}async function g(){try{const z=await(await fetch("/api/v1/notifications/history?limit=10")).json(),C=document.getElementById("notification-history");z.success&&z.history?.length>0?C.innerHTML=z.history.map(H=>{const b=new Date(H.timestamp).toLocaleString();return`
+  </div>`);const E=document.getElementById("notifications-modal"),j=document.getElementById("manage-notifications"),h=document.getElementById("notifications-save"),P=document.getElementById("notifications-cancel");["discord","telegram","ntfy","email"].forEach(T=>{const z=document.getElementById(`${T}-enabled`),C=document.getElementById(`${T}-config`);z?.addEventListener("change",()=>{C.style.display=z.checked?"block":"none"})});const A=document.getElementById("health-check-enabled"),D=document.getElementById("health-check-config");A?.addEventListener("change",()=>{D.style.opacity=A.checked?"1":"0.5"});async function R(){try{const z=await(await fetch("/api/v1/notifications/config")).json();if(z.success){const C=z.config;document.getElementById("notifications-enabled").checked=C.enabled,document.getElementById("discord-enabled").checked=C.providers?.discord?.enabled||!1,document.getElementById("telegram-enabled").checked=C.providers?.telegram?.enabled||!1,document.getElementById("ntfy-enabled").checked=C.providers?.ntfy?.enabled||!1,document.getElementById("email-enabled").checked=C.providers?.email?.enabled||!1,document.getElementById("discord-config").style.display=C.providers?.discord?.enabled?"block":"none",document.getElementById("telegram-config").style.display=C.providers?.telegram?.enabled?"block":"none",document.getElementById("ntfy-config").style.display=C.providers?.ntfy?.enabled?"block":"none",document.getElementById("email-config").style.display=C.providers?.email?.enabled?"block":"none",C.providers?.ntfy?.serverUrl&&(document.getElementById("ntfy-server").value=C.providers.ntfy.serverUrl),C.providers?.email?.host&&(document.getElementById("email-host").value=C.providers.email.host),C.providers?.email?.from&&(document.getElementById("email-from").value=C.providers.email.from),C.providers?.email?.to&&(document.getElementById("email-to").value=C.providers.email.to),C.providers?.email?.port&&(document.getElementById("email-port").value=C.providers.email.port),C.providers?.email?.secure!==void 0&&(document.getElementById("email-secure").checked=C.providers.email.secure===!0),C.providers?.email?.username&&(document.getElementById("email-user").value=C.providers.email.username);const M=document.getElementById("email-pass");C.providers?.email?.hasPassword?(M.value="",M.placeholder="saved \u2014 leave blank to keep"):M.placeholder="app password",document.getElementById("health-check-enabled").checked=C.healthCheck?.enabled||!1,C.healthCheck?.intervalMinutes&&(document.getElementById("health-check-interval").value=C.healthCheck.intervalMinutes),C.healthCheck?.lastCheck&&(document.getElementById("health-check-status").textContent=`Last check: ${new Date(C.healthCheck.lastCheck).toLocaleString()}`),document.getElementById("event-container-down").checked=C.events?.["container-down"]!==!1,document.getElementById("event-container-up").checked=C.events?.["container-up"]===!0,document.getElementById("event-deploy-success").checked=C.events?.["deploy-success"]!==!1,document.getElementById("event-deploy-failed").checked=C.events?.["deploy-failed"]!==!1,document.getElementById("event-ssl-cert-expiry").checked=C.events?.["ssl-cert-expiry"]!==!1,document.getElementById("event-dns-propagation").checked=C.events?.["dns-propagation"]!==!1,document.getElementById("event-drift-detected").checked=C.events?.["drift-detected"]!==!1,document.getElementById("event-dependency-restart").checked=C.events?.["dependency-restart"]!==!1,document.getElementById("event-recipe-removed").checked=C.events?.["recipe-removed"]!==!1,document.getElementById("event-workflow").checked=C.events?.workflow!==!1,document.getElementById("event-backup-complete").checked=C.events?.["backup-complete"]!==!1,document.getElementById("event-backup-failed").checked=C.events?.["backup-failed"]!==!1,document.getElementById("event-update-available").checked=C.events?.["update-available"]!==!1,document.getElementById("event-resource-alert").checked=C.events?.alert!==!1}}catch(T){x.logError("[Notifications] Load Config",T,{function:"loadConfig"})}}async function y(){try{const z=await(await fetch("/api/v1/notifications/history?limit=10")).json(),C=document.getElementById("notification-history");z.success&&z.history?.length>0?C.innerHTML=z.history.map(M=>{const b=new Date(M.timestamp).toLocaleString();return`
             <div style="padding: 6px 8px; border-bottom: 1px solid var(--border); display: flex; gap: 8px; align-items: flex-start;">
-              <span style="color: ${{success:"var(--ok-fg)",error:"var(--bad-fg)",warning:"#f39c12",info:"var(--accent)"}[H.type]||"var(--muted)"}">${H.type==="success"?"\u2713":H.type==="error"?"\u2717":"\u2139"}</span>
+              <span style="color: ${{success:"var(--ok-fg)",error:"var(--bad-fg)",warning:"#f39c12",info:"var(--accent)"}[M.type]||"var(--muted)"}">${M.type==="success"?"\u2713":M.type==="error"?"\u2717":"\u2139"}</span>
               <div style="flex: 1; min-width: 0;">
-                <div style="font-weight: 500; white-space: nowrap; overflow: hidden; text-overflow: ellipsis;">${escapeHtml(H.title)}</div>
+                <div style="font-weight: 500; white-space: nowrap; overflow: hidden; text-overflow: ellipsis;">${escapeHtml(M.title)}</div>
                 <div style="font-size: 0.7rem; color: var(--muted);">${b}</div>
               </div>
             </div>
-          `}).join(""):C.innerHTML='<div style="color: var(--muted); text-align: center; padding: 20px;">No notifications yet</div>'}catch(T){x.logError("[Notifications] Load History",T,{function:"loadHistory"})}}async function $(){try{const T={enabled:document.getElementById("notifications-enabled").checked,providers:{discord:{enabled:document.getElementById("discord-enabled").checked,webhookUrl:document.getElementById("discord-webhook").value.trim()},telegram:{enabled:document.getElementById("telegram-enabled").checked,botToken:document.getElementById("telegram-bot-token").value.trim(),chatId:document.getElementById("telegram-chat-id").value.trim()},ntfy:{enabled:document.getElementById("ntfy-enabled").checked,serverUrl:document.getElementById("ntfy-server").value.trim()||"https://ntfy.sh",topic:document.getElementById("ntfy-topic").value.trim()},email:{enabled:document.getElementById("email-enabled").checked,host:document.getElementById("email-host").value.trim(),port:parseInt(document.getElementById("email-port").value)||587,secure:document.getElementById("email-secure").checked,username:document.getElementById("email-user").value.trim(),password:document.getElementById("email-pass").value.trim(),from:document.getElementById("email-from").value.trim(),to:document.getElementById("email-to").value.trim()}},events:{"container-down":document.getElementById("event-container-down").checked,"container-up":document.getElementById("event-container-up").checked,"deploy-success":document.getElementById("event-deploy-success").checked,"deploy-failed":document.getElementById("event-deploy-failed").checked,"ssl-cert-expiry":document.getElementById("event-ssl-cert-expiry").checked,"dns-propagation":document.getElementById("event-dns-propagation").checked,"drift-detected":document.getElementById("event-drift-detected").checked,"dependency-restart":document.getElementById("event-dependency-restart").checked,"recipe-removed":document.getElementById("event-recipe-removed").checked,workflow:document.getElementById("event-workflow").checked,"backup-complete":document.getElementById("event-backup-complete").checked,"backup-failed":document.getElementById("event-backup-failed").checked,"update-available":document.getElementById("event-update-available").checked,alert:document.getElementById("event-resource-alert").checked},healthCheck:{enabled:document.getElementById("health-check-enabled").checked,intervalMinutes:parseInt(document.getElementById("health-check-interval").value)||5}},C=await(await secureFetch("/api/v1/notifications/config",{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify(T)})).json();C.success?(showNotification("Notification settings saved","success",3e3),E.classList.remove("show")):showNotification(`Failed to save: ${C.error}`,"error",3e3)}catch(T){showNotification(`Error: ${T.message}`,"error",3e3)}}async function k(T){try{const C=await(await secureFetch("/api/v1/notifications/test",{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify({provider:T})})).json();C.success?showNotification(`Test ${T} notification sent!`,"success",3e3):showNotification(`Test failed: ${C.error}`,"error",3e3)}catch(z){showNotification(`Error: ${z.message}`,"error",3e3)}}document.getElementById("discord-test")?.addEventListener("click",()=>k("discord")),document.getElementById("telegram-test")?.addEventListener("click",()=>k("telegram")),document.getElementById("ntfy-test")?.addEventListener("click",()=>k("ntfy")),document.getElementById("email-test")?.addEventListener("click",()=>k("email")),document.getElementById("health-check-now")?.addEventListener("click",async()=>{try{const z=await(await secureFetch("/api/v1/notifications/health-check",{method:"POST"})).json();z.success&&(document.getElementById("health-check-status").textContent=`Last check: ${new Date(z.lastCheck).toLocaleString()} (${z.containersMonitored} containers)`,showNotification("Health check completed","success",2e3))}catch(T){showNotification(`Error: ${T.message}`,"error",3e3)}}),R?.addEventListener("click",()=>{E.classList.add("show"),j(),g()}),h?.addEventListener("click",$),document.getElementById("notifications-send-test")?.addEventListener("click",async()=>{const T=document.getElementById("notifications-send-test"),z=T.textContent;T.textContent="Sending...",T.disabled=!0;try{const H=await(await secureFetch("/api/v1/notifications/send",{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify({event:"test",data:{message:"This is a test notification from DashCaddy."},type:"info"})})).json();H.success?(showNotification("Test notification sent!","success",3e3),M()):showNotification(`Test failed: ${H.results?.map(b=>`${b.provider}: ${b.error||"ok"}`).join(", ")}`,"error",5e3)}catch(C){showNotification(`Error: ${C.message}`,"error",3e3)}finally{T.textContent=z,T.disabled=!1}});async function M(){try{const z=await(await fetch("/api/v1/notifications/status")).json();if(z.success&&z.lastSent){const C=document.getElementById("last-notification-sent");C&&(C.textContent=`Last sent: ${new Date(z.lastSent).toLocaleString()}`)}}catch{}}wireModal(E,P)})(),(function(){document.addEventListener("click",x=>{const E=x.target.closest(".panel-tab");if(!E)return;const R=E.dataset.panel;if(!R)return;const h=E.closest(".panel-tabs"),P=h.closest(".weather-modal-content");h.querySelectorAll(".panel-tab").forEach(D=>D.classList.remove("active")),E.classList.add("active"),P.querySelectorAll(".panel-section").forEach(D=>D.classList.remove("active"));const A=P.querySelector("#"+R);A&&A.classList.add("active")})})(),(function(){var x=["dashcaddy_site_config","dashcaddy_onboarding","dashcaddy-encryption-key","dashcaddy-setup","dashcaddy-config","theme","user-themes","custom-theme","custom-apps","custom-services","toolbar-sections","weather-location","weather-zip","weather-geo","weather-unit","clock-style","clock-chimes","clock-chime-volume"];function E(){for(var e={},s=0;s<x.length;s++){var n=x[s],r=safeGet(n);r!=null&&(e[n]=r)}try{for(var a=0;a<localStorage.length;a++){var i=localStorage.key(a);/^widget-.+-enabled$/.test(i)&&(e[i]=localStorage.getItem(i))}}catch{}return e}function R(e){if(!e||typeof e!="object")return 0;var s=0;for(var n in e)e.hasOwnProperty(n)&&(safeSet(n,e[n]),s++);return s}function h(e){return e.version&&!e.files&&e.services}function P(e){var s={};e.customServices&&(s["custom-services"]=JSON.stringify(e.customServices)),e.customApps&&(s["custom-apps"]=JSON.stringify(e.customApps)),e.weatherZip&&(s["weather-zip"]=e.weatherZip),e.theme&&(s.theme=e.theme),e.userThemes&&Object.keys(e.userThemes).length&&(s["user-themes"]=JSON.stringify(e.userThemes)),R(s),e.services&&Array.isArray(e.services)&&secureFetch("/api/v1/services",{method:"PUT",headers:{"Content-Type":"application/json"},body:JSON.stringify(e.services)}).catch(function(){}),e.userThemes&&Object.keys(e.userThemes).forEach(function(n){var r=e.userThemes[n],a={};(window.THEME_PROPS||[]).forEach(function(i){r[i]&&(a[i]=r[i])}),secureFetch("/api/v1/themes/"+n,{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify({name:r.name||n,colors:a})}).catch(function(){})})}injectModal("backup-modal",`<div id="backup-modal" class="weather-modal">
+          `}).join(""):C.innerHTML='<div style="color: var(--muted); text-align: center; padding: 20px;">No notifications yet</div>'}catch(T){x.logError("[Notifications] Load History",T,{function:"loadHistory"})}}async function $(){try{const T={enabled:document.getElementById("notifications-enabled").checked,providers:{discord:{enabled:document.getElementById("discord-enabled").checked,webhookUrl:document.getElementById("discord-webhook").value.trim()},telegram:{enabled:document.getElementById("telegram-enabled").checked,botToken:document.getElementById("telegram-bot-token").value.trim(),chatId:document.getElementById("telegram-chat-id").value.trim()},ntfy:{enabled:document.getElementById("ntfy-enabled").checked,serverUrl:document.getElementById("ntfy-server").value.trim()||"https://ntfy.sh",topic:document.getElementById("ntfy-topic").value.trim()},email:{enabled:document.getElementById("email-enabled").checked,host:document.getElementById("email-host").value.trim(),port:parseInt(document.getElementById("email-port").value)||587,secure:document.getElementById("email-secure").checked,username:document.getElementById("email-user").value.trim(),password:document.getElementById("email-pass").value.trim(),from:document.getElementById("email-from").value.trim(),to:document.getElementById("email-to").value.trim()}},events:{"container-down":document.getElementById("event-container-down").checked,"container-up":document.getElementById("event-container-up").checked,"deploy-success":document.getElementById("event-deploy-success").checked,"deploy-failed":document.getElementById("event-deploy-failed").checked,"ssl-cert-expiry":document.getElementById("event-ssl-cert-expiry").checked,"dns-propagation":document.getElementById("event-dns-propagation").checked,"drift-detected":document.getElementById("event-drift-detected").checked,"dependency-restart":document.getElementById("event-dependency-restart").checked,"recipe-removed":document.getElementById("event-recipe-removed").checked,workflow:document.getElementById("event-workflow").checked,"backup-complete":document.getElementById("event-backup-complete").checked,"backup-failed":document.getElementById("event-backup-failed").checked,"update-available":document.getElementById("event-update-available").checked,alert:document.getElementById("event-resource-alert").checked},healthCheck:{enabled:document.getElementById("health-check-enabled").checked,intervalMinutes:parseInt(document.getElementById("health-check-interval").value)||5}},C=await(await secureFetch("/api/v1/notifications/config",{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify(T)})).json();C.success?(showNotification("Notification settings saved","success",3e3),E.classList.remove("show")):showNotification(`Failed to save: ${C.error}`,"error",3e3)}catch(T){showNotification(`Error: ${T.message}`,"error",3e3)}}async function k(T){try{const C=await(await secureFetch("/api/v1/notifications/test",{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify({provider:T})})).json();C.success?showNotification(`Test ${T} notification sent!`,"success",3e3):showNotification(`Test failed: ${C.error}`,"error",3e3)}catch(z){showNotification(`Error: ${z.message}`,"error",3e3)}}document.getElementById("discord-test")?.addEventListener("click",()=>k("discord")),document.getElementById("telegram-test")?.addEventListener("click",()=>k("telegram")),document.getElementById("ntfy-test")?.addEventListener("click",()=>k("ntfy")),document.getElementById("email-test")?.addEventListener("click",()=>k("email")),document.getElementById("health-check-now")?.addEventListener("click",async()=>{try{const z=await(await secureFetch("/api/v1/notifications/health-check",{method:"POST"})).json();z.success&&(document.getElementById("health-check-status").textContent=`Last check: ${new Date(z.lastCheck).toLocaleString()} (${z.containersMonitored} containers)`,showNotification("Health check completed","success",2e3))}catch(T){showNotification(`Error: ${T.message}`,"error",3e3)}}),j?.addEventListener("click",()=>{E.classList.add("show"),R(),y()}),h?.addEventListener("click",$),document.getElementById("notifications-send-test")?.addEventListener("click",async()=>{const T=document.getElementById("notifications-send-test"),z=T.textContent;T.textContent="Sending...",T.disabled=!0;try{const M=await(await secureFetch("/api/v1/notifications/send",{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify({event:"test",data:{message:"This is a test notification from DashCaddy."},type:"info"})})).json();M.success?(showNotification("Test notification sent!","success",3e3),H()):showNotification(`Test failed: ${M.results?.map(b=>`${b.provider}: ${b.error||"ok"}`).join(", ")}`,"error",5e3)}catch(C){showNotification(`Error: ${C.message}`,"error",3e3)}finally{T.textContent=z,T.disabled=!1}});async function H(){try{const z=await(await fetch("/api/v1/notifications/status")).json();if(z.success&&z.lastSent){const C=document.getElementById("last-notification-sent");C&&(C.textContent=`Last sent: ${new Date(z.lastSent).toLocaleString()}`)}}catch{}}wireModal(E,P)})(),(function(){document.addEventListener("click",x=>{const E=x.target.closest(".panel-tab");if(!E)return;const j=E.dataset.panel;if(!j)return;const h=E.closest(".panel-tabs"),P=h.closest(".weather-modal-content");h.querySelectorAll(".panel-tab").forEach(D=>D.classList.remove("active")),E.classList.add("active"),P.querySelectorAll(".panel-section").forEach(D=>D.classList.remove("active"));const A=P.querySelector("#"+j);A&&A.classList.add("active")})})(),(function(){var x=["dashcaddy_site_config","dashcaddy_onboarding","dashcaddy-encryption-key","dashcaddy-setup","dashcaddy-config","theme","user-themes","custom-theme","custom-apps","custom-services","toolbar-sections","weather-location","weather-zip","weather-geo","weather-unit","clock-style","clock-chimes","clock-chime-volume"];function E(){for(var e={},s=0;s<x.length;s++){var n=x[s],r=safeGet(n);r!=null&&(e[n]=r)}try{for(var a=0;a<localStorage.length;a++){var i=localStorage.key(a);/^widget-.+-enabled$/.test(i)&&(e[i]=localStorage.getItem(i))}}catch{}return e}function j(e){if(!e||typeof e!="object")return 0;var s=0;for(var n in e)e.hasOwnProperty(n)&&(safeSet(n,e[n]),s++);return s}function h(e){return e.version&&!e.files&&e.services}function P(e){var s={};e.customServices&&(s["custom-services"]=JSON.stringify(e.customServices)),e.customApps&&(s["custom-apps"]=JSON.stringify(e.customApps)),e.weatherZip&&(s["weather-zip"]=e.weatherZip),e.theme&&(s.theme=e.theme),e.userThemes&&Object.keys(e.userThemes).length&&(s["user-themes"]=JSON.stringify(e.userThemes)),j(s),e.services&&Array.isArray(e.services)&&secureFetch("/api/v1/services",{method:"PUT",headers:{"Content-Type":"application/json"},body:JSON.stringify(e.services)}).catch(function(){}),e.userThemes&&Object.keys(e.userThemes).forEach(function(n){var r=e.userThemes[n],a={};(window.THEME_PROPS||[]).forEach(function(i){r[i]&&(a[i]=r[i])}),secureFetch("/api/v1/themes/"+n,{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify({name:r.name||n,colors:a})}).catch(function(){})})}injectModal("backup-modal",`<div id="backup-modal" class="weather-modal">
     <div class="weather-modal-content" style="min-width: 550px; max-width: 650px;">
       <h3>\u{1F4BE} Backup & Restore</h3>
       <p class="modal-subtitle">
@@ -1223,7 +1223,7 @@ Try refreshing in a moment if you see a certificate error.`,"warning",1e4),!1}};
         <button id="backup-cancel">Close</button>
       </div>
     </div>
-  </div>`);var A=document.getElementById("backup-modal"),D=document.getElementById("backup-restore-btn"),j=document.getElementById("backup-cancel"),g=document.getElementById("backup-export-btn"),$=document.getElementById("backup-select-file"),k=document.getElementById("backup-file-input"),M=document.getElementById("backup-file-name"),T=document.getElementById("backup-preview"),z=document.getElementById("backup-preview-content"),C=document.getElementById("backup-do-restore-btn"),H=document.getElementById("backup-result"),b=document.getElementById("backup-schedules-container"),d=document.getElementById("backup-history-container"),v=document.getElementById("backup-disk-container"),S=document.getElementById("pointintime-container"),O=null;D?.addEventListener("click",function(){A.classList.add("show"),H&&(H.style.display="none"),T&&(T.style.display="none"),M&&(M.style.display="none"),O=null}),wireModal(A,j),g?.addEventListener("click",async function(){g.disabled=!0,g.innerHTML='<span class="brand-spinner"></span> Exporting...';try{var e=await fetch("/api/v1/backup/export"),s=await e.json();s.browserState=E();var n=new Blob([JSON.stringify(s,null,2)],{type:"application/json"}),r=URL.createObjectURL(n),a=document.createElement("a");a.href=r,a.download="dashcaddy-backup-"+new Date().toISOString().split("T")[0]+".json",document.body.appendChild(a),a.click(),document.body.removeChild(a),URL.revokeObjectURL(r);var i=Object.keys(s.browserState).length,c=s.themes?Object.keys(s.themes).length:0;H.innerHTML="\u2705 Full backup downloaded \u2014 server config + "+i+" browser settings"+(c?" + "+c+" themes":""),H.style.display="block",H.style.background="color-mix(in srgb, var(--ok-fg) 15%, transparent)",H.style.border="1px solid var(--ok-fg)"}catch(I){H.innerHTML="\u274C Export failed: "+escapeHtml(I.message),H.style.display="block",H.style.background="color-mix(in srgb, var(--bad-fg) 15%, transparent)",H.style.border="1px solid var(--bad-fg)"}g.disabled=!1,g.innerHTML="\u2B07\uFE0F Download Full Backup"}),$?.addEventListener("click",function(){k.click()}),k?.addEventListener("change",async function(e){var s=e.target.files[0];if(s){M.textContent="\u{1F4C4} "+s.name,M.style.display="block",H.style.display="none";try{var n=await s.text(),r=JSON.parse(n);if(h(r)){O=r;var a='<div style="margin-bottom: 8px; color: var(--muted); font-size: 0.8rem;">Legacy format (v'+escapeHtml(r.version)+")</div>";a+='<div style="display: flex; flex-wrap: wrap; gap: 6px;">',r.services?.length&&(a+='<span style="padding: 4px 8px; background: var(--base); border-radius: 4px; font-size: 0.8rem;">\u{1F4CB} '+r.services.length+" services</span>"),r.customApps?.length&&(a+='<span style="padding: 4px 8px; background: var(--base); border-radius: 4px; font-size: 0.8rem;">\u{1F4E6} '+r.customApps.length+" custom apps</span>"),r.theme&&(a+='<span style="padding: 4px 8px; background: var(--base); border-radius: 4px; font-size: 0.8rem;">\u{1F3A8} Theme: '+escapeHtml(r.theme)+"</span>"),r.userThemes&&(a+='<span style="padding: 4px 8px; background: var(--base); border-radius: 4px; font-size: 0.8rem;">\u{1F3A8} '+Object.keys(r.userThemes).length+" custom themes</span>"),a+="</div>",z.innerHTML=a,T.style.display="block";return}var i=await secureFetch("/api/v1/backup/preview",{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify(r)}),c=await i.json();if(c.success){O=r;var a='<div style="margin-bottom: 8px; color: var(--muted); font-size: 0.8rem;">Exported: '+new Date(r.exportedAt).toLocaleString()+" (v"+escapeHtml(r.version)+")</div>";a+='<div style="margin-bottom: 6px; font-size: 0.75rem; color: var(--muted); text-transform: uppercase; letter-spacing: 0.5px;">Server Config</div>',a+='<div style="display: flex; flex-wrap: wrap; gap: 6px; margin-bottom: 10px;">';for(var I in c.preview.files){var N=c.preview.files[I],U=N.action==="create"?"\u{1F195}":"\u{1F4DD}";a+='<span style="padding: 4px 8px; background: var(--base); border-radius: 4px; font-size: 0.8rem;">'+U+" "+escapeHtml(N.description)+"</span>"}a+="</div>",c.preview.serviceCount&&(a+='<div style="font-size: 0.8rem; color: var(--accent); margin-bottom: 6px;">'+c.preview.serviceCount+" services</div>"),c.preview.themeCount&&(a+='<div style="font-size: 0.8rem; color: var(--accent); margin-bottom: 6px;">\u{1F3A8} '+c.preview.themeCount+" custom themes</div>"),c.preview.browserStateCount&&(a+='<div style="margin-top: 6px; font-size: 0.75rem; color: var(--muted); text-transform: uppercase; letter-spacing: 0.5px;">Browser Preferences</div>',a+='<div style="font-size: 0.8rem; color: var(--accent);">\u{1F5A5}\uFE0F '+c.preview.browserStateCount+" saved settings (theme, weather, clock, widgets, etc.)</div>"),z.innerHTML=a,T.style.display="block"}else H.innerHTML="\u26A0\uFE0F Invalid backup file: "+escapeHtml(c.error),H.style.display="block",H.style.background="color-mix(in srgb, #f39c12 15%, transparent)",H.style.border="1px solid #f39c12",T.style.display="none"}catch(_){H.innerHTML="\u274C Could not read file: "+escapeHtml(_.message),H.style.display="block",H.style.background="color-mix(in srgb, var(--bad-fg) 15%, transparent)",H.style.border="1px solid var(--bad-fg)",T.style.display="none"}}}),C?.addEventListener("click",async function(){if(O&&confirm("This will overwrite your current configuration and browser preferences. Continue?")){C.disabled=!0,C.innerHTML='<span class="brand-spinner"></span> Restoring...';try{if(h(O)){P(O),H.innerHTML="\u2705 Legacy backup restored \u2014 browser settings and services imported.",H.style.background="color-mix(in srgb, var(--ok-fg) 15%, transparent)",H.style.border="1px solid var(--ok-fg)",H.style.display="block",setTimeout(function(){location.reload()},2e3),C.disabled=!1,C.innerHTML="\u26A1 Restore Everything";return}var e=document.getElementById("backup-reload-caddy")?.checked??!0,s=await secureFetch("/api/v1/backup/restore",{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify({backup:O,options:{reloadCaddy:e}})}),n=await s.json(),r=0;if(O.browserState&&(r=R(O.browserState)),n.success){var a="\u2705 "+n.message;r>0&&(a+='<br><small style="color: var(--muted);">'+r+" browser settings restored</small>"),n.results.caddyReloaded&&(a+='<br><small style="color: var(--muted);">Caddy configuration reloaded</small>'),H.innerHTML=a,H.style.background="color-mix(in srgb, var(--ok-fg) 15%, transparent)",H.style.border="1px solid var(--ok-fg)",setTimeout(function(){location.reload()},2e3)}else H.innerHTML="\u26A0\uFE0F "+escapeHtml(n.message),r>0&&(H.innerHTML+='<br><small style="color: var(--muted);">'+r+" browser settings were restored</small>"),n.results?.errors?.length>0&&(H.innerHTML+="<br><small>"+n.results.errors.map(function(i){return escapeHtml(i.file)+": "+escapeHtml(i.error)}).join(", ")+"</small>"),H.style.background="color-mix(in srgb, #f39c12 15%, transparent)",H.style.border="1px solid #f39c12";H.style.display="block"}catch(i){H.innerHTML="\u274C Restore failed: "+escapeHtml(i.message),H.style.display="block",H.style.background="color-mix(in srgb, var(--bad-fg) 15%, transparent)",H.style.border="1px solid var(--bad-fg)"}C.disabled=!1,C.innerHTML="\u26A1 Restore Everything"}});async function m(){if(b){b.innerHTML='<div class="panel-empty"><span class="brand-spinner"></span> Loading...</div>';try{var e=await fetch("/api/v1/backups/schedule"),s=await e.json();if(s.premiumRequired){b.innerHTML=`<div class="panel-empty" style="padding: 24px; text-align: center;"><div style="font-size: 2rem; margin-bottom: 12px;">\u2B50</div><div style="font-weight: 600; margin-bottom: 8px;">Premium Feature</div><div style="font-size: 0.85rem; color: var(--muted);">Auto-backup scheduling requires a DashCaddy Premium subscription.</div><button onclick="showNotification('Upgrade to Premium to enable auto-backups!', 'info'); scrollToSection('license');" style="margin-top: 16px; padding: 8px 20px; background: linear-gradient(135deg, #f39c12, #e67e22); border: none; color: white; border-radius: 8px; cursor: pointer; font-weight: 600;">Upgrade to Premium</button></div>`;return}if(!s.success)throw new Error(s.error||"Failed to load schedules");var n=s.schedules||[];if(n.length===0){b.innerHTML='<div class="panel-empty"><span class="empty-icon">\u23F0</span><div>No backup schedules configured</div><div style="font-size: 0.8rem; color: var(--muted); margin-top: 4px;">Select apps below to enable auto-backup</div></div>';return}for(var r='<div style="display: flex; flex-direction: column; gap: 8px;">',a=0;a<n.length;a++){var i=n[a],c=i.nextRun?new Date(i.nextRun).toLocaleString():"Not scheduled",I=i.lastRun?new Date(i.lastRun).toLocaleString():"Never";r+='<div style="padding: 12px 14px; background: var(--card-base); border-radius: 8px; border: 1px solid var(--border);"><div style="display: flex; justify-content: space-between; align-items: center; margin-bottom: 8px;">  <div style="font-weight: 600; font-size: 0.9rem;">'+escapeHtml(i.appId)+'</div>  <label class="toggle-switch" style="display: flex; align-items: center; gap: 6px;">    <input type="checkbox" class="schedule-toggle" data-appid="'+escapeHtml(i.appId)+'"'+(i.enabled?" checked":"")+' />    <span style="font-size: 0.75rem; color: var(--muted);">'+(i.enabled?"ON":"OFF")+'</span>  </label></div><div style="display: grid; grid-template-columns: 1fr 1fr; gap: 8px; font-size: 0.8rem; margin-bottom: 10px;">  <div><span style="color: var(--muted);">Schedule:</span> <select class="schedule-select" data-appid="'+escapeHtml(i.appId)+'" style="background: var(--base); border: 1px solid var(--border); border-radius: 4px; padding: 2px 6px;">    <option value="hourly"'+(i.schedule==="hourly"?" selected":"")+'>Hourly</option>    <option value="daily"'+(i.schedule==="daily"?" selected":"")+'>Daily</option>    <option value="weekly"'+(i.schedule==="weekly"?" selected":"")+'>Weekly</option>    <option value="monthly"'+(i.schedule==="monthly"?" selected":"")+'>Monthly</option>  </select></div>  <div><span style="color: var(--muted);">Keep last:</span> <input type="number" class="retention-input" data-appid="'+escapeHtml(i.appId)+'" value="'+(i.retention?.keep||7)+'" min="1" max="100" style="width: 50px; background: var(--base); border: 1px solid var(--border); border-radius: 4px; padding: 2px 6px;" /></div></div><div style="font-size: 0.75rem; color: var(--muted); margin-bottom: 10px;">  <div>Next run: '+escapeHtml(c)+"</div>  <div>Last run: "+escapeHtml(I)+'</div></div><div style="display: flex; gap: 6px;">  <button class="schedule-run-now" data-appid="'+escapeHtml(i.appId)+'" style="padding: 5px 12px; font-size: 0.8rem; background: color-mix(in srgb, var(--ok-fg) 20%, transparent); border: 1px solid var(--ok-fg); color: var(--ok-fg); border-radius: 6px; cursor: pointer;">\u25B6\uFE0F Run Now</button>  <button class="schedule-delete" data-appid="'+escapeHtml(i.appId)+'" style="padding: 5px 12px; font-size: 0.8rem; background: transparent; border: 1px solid var(--bad-fg); color: var(--bad-fg); border-radius: 6px; cursor: pointer;">\u{1F5D1}\uFE0F Remove</button></div></div>'}r+="</div>",r+='<div style="margin-top: 16px; padding: 16px; background: color-mix(in srgb, var(--accent) 5%, transparent); border-radius: 10px; border: 1px dashed var(--border);"><h4 style="margin: 0 0 12px; font-size: 0.85rem; color: var(--muted);">\u2795 Add New Schedule</h4><div style="display: flex; gap: 8px; flex-wrap: wrap;">  <input type="text" id="new-schedule-appid" placeholder="App ID (e.g., plex, sonarr)" style="flex: 1; min-width: 150px; padding: 8px; border-radius: 6px; border: 1px solid var(--border); background: var(--base);" />  <select id="new-schedule-interval" style="padding: 8px; border-radius: 6px; border: 1px solid var(--border); background: var(--base);">    <option value="hourly">Hourly</option>    <option value="daily" selected>Daily</option>    <option value="weekly">Weekly</option>    <option value="monthly">Monthly</option>    <option value="6h">Every 6 hours</option>    <option value="30m">Every 30 minutes</option>  </select>  <input type="number" id="new-schedule-retention" value="7" min="1" max="100" placeholder="Keep" style="width: 70px; padding: 8px; border-radius: 6px; border: 1px solid var(--border); background: var(--base);" />  <button id="add-schedule-btn" style="padding: 8px 16px; background: var(--accent); border: none; color: white; border-radius: 6px; cursor: pointer; font-weight: 500;">Add Schedule</button></div></div>',b.innerHTML=r,b.querySelectorAll(".schedule-toggle").forEach(function(N){N.addEventListener("change",function(){f(N.dataset.appid,{enabled:N.checked})})}),b.querySelectorAll(".schedule-select").forEach(function(N){N.addEventListener("change",function(){f(N.dataset.appid,{schedule:N.value})})}),b.querySelectorAll(".retention-input").forEach(function(N){N.addEventListener("change",function(){f(N.dataset.appid,{retention:{keep:parseInt(N.value)||7}})})}),b.querySelectorAll(".schedule-run-now").forEach(function(N){N.addEventListener("click",function(){B(N.dataset.appid)})}),b.querySelectorAll(".schedule-delete").forEach(function(N){N.addEventListener("click",function(){w(N.dataset.appid)})}),document.getElementById("add-schedule-btn")?.addEventListener("click",L)}catch(N){b.innerHTML='<div class="panel-empty" style="color: var(--bad-fg);">Failed to load: '+escapeHtml(N.message)+"</div>"}}}async function f(e,s){try{var n=await secureFetch("/api/v1/backups/schedule",{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify({appId:e,...s})}),r=await n.json();r.success?showNotification("Schedule updated for "+e,"success"):(showNotification("Update failed: "+(r.error||"Unknown"),"error"),m())}catch(a){showNotification("Error: "+a.message,"error")}}async function B(e){try{var s=await secureFetch("/api/v1/backups/backup/"+encodeURIComponent(e),{method:"POST",headers:{"Content-Type":"application/json"}}),n=await s.json();n.success?showNotification("Backup started for "+e+"!","success"):showNotification("Backup failed: "+(n.error||"Unknown"),"error")}catch(r){showNotification("Error: "+r.message,"error")}}async function w(e){if(confirm("Remove backup schedule for "+e+"?"))try{var s=await secureFetch("/api/v1/backups/schedule/"+encodeURIComponent(e),{method:"DELETE"}),n=await s.json();n.success?(showNotification("Schedule removed for "+e,"success"),m()):showNotification("Delete failed: "+(n.error||"Unknown"),"error")}catch(r){showNotification("Error: "+r.message,"error")}}async function L(){var e=document.getElementById("new-schedule-appid")?.value?.trim(),s=document.getElementById("new-schedule-interval")?.value||"daily",n=parseInt(document.getElementById("new-schedule-retention")?.value)||7;if(!e){showNotification("Please enter an App ID","warning");return}try{var r=await secureFetch("/api/v1/backups/schedule",{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify({appId:e,schedule:s,retention:{keep:n},enabled:!0})}),a=await r.json();if(a.success){showNotification("Schedule created for "+e,"success"),m();var i=document.getElementById("new-schedule-appid");i&&(i.value="")}else showNotification("Failed: "+(a.error||"Unknown"),"error")}catch(c){showNotification("Error: "+c.message,"error")}}async function o(){if(v){v.innerHTML='<div class="panel-empty"><span class="brand-spinner"></span> Loading...</div>';try{var e=await fetch("/api/v1/backups/files"),s=await e.json();if(!s.success)throw new Error(s.error||"Failed to load");var n=s.files||[];if(n.length===0){v.innerHTML='<div class="panel-empty"><span class="empty-icon">\u{1F4BE}</span><div>No backup files on disk</div><div style="font-size: 0.8rem; color: var(--muted); margin-top: 4px;">Run a backup to create backup files</div></div>';return}for(var r={},a=0;a<n.length;a++){var i=n[a],c=i.appId||"unknown";r[c]||(r[c]=[]),r[c].push(i)}var I='<div style="font-size: 0.75rem; color: var(--muted); margin-bottom: 12px;">'+n.length+" backup file(s) across "+Object.keys(r).length+" app(s)</div>";I+='<div style="display: flex; flex-direction: column; gap: 12px;">';for(var N=Object.keys(r).sort(),U=0;U<N.length;U++){var c=N[U],_=r[c];I+='<div style="background: var(--card-base); border-radius: 8px; border: 1px solid var(--border); overflow: hidden;"><div style="padding: 8px 12px; background: color-mix(in srgb, var(--accent) 8%, transparent); border-bottom: 1px solid var(--border); font-weight: 600; font-size: 0.85rem;">'+escapeHtml(c)+' <span style="font-weight: normal; color: var(--muted); font-size: 0.75rem;">('+_.length+" backup(s))</span></div>";for(var F=0;F<_.length;F++){var i=_[F],q=new Date(i.timestamp).toLocaleString();I+='<div style="padding: 10px 12px; border-bottom: 1px solid var(--border);"><div style="display: flex; justify-content: space-between; align-items: center; margin-bottom: 4px;">  <div style="font-weight: 500; font-size: 0.85rem;">'+escapeHtml(i.name)+'</div>  <div style="font-size: 0.75rem; color: var(--muted);">'+i.sizeFormatted+'</div></div><div style="font-size: 0.75rem; color: var(--muted); margin-bottom: 8px;">'+q+'</div><div style="display: flex; gap: 6px;">  <button class="disk-compare-btn" data-appid="'+escapeHtml(c)+'" data-filename="'+escapeHtml(i.name)+'" style="padding: 3px 8px; font-size: 0.75rem; background: transparent; border: 1px solid var(--accent); color: var(--accent); border-radius: 5px; cursor: pointer;">Compare</button>  <button class="disk-restore-btn" data-appid="'+escapeHtml(c)+'" data-filename="'+escapeHtml(i.name)+'" style="padding: 3px 8px; font-size: 0.75rem; background: linear-gradient(135deg, var(--ok-fg), #27ae60); border: none; color: white; border-radius: 5px; cursor: pointer; font-weight: 500;">Restore</button></div></div>'}I+="</div>"}I+="</div>",v.innerHTML=I,v.querySelectorAll(".disk-compare-btn").forEach(function(J){J.addEventListener("click",function(){u(J.dataset.appid,J.dataset.filename)})}),v.querySelectorAll(".disk-restore-btn").forEach(function(J){J.addEventListener("click",function(){t(J.dataset.appid,J.dataset.filename)})})}catch(J){v.innerHTML='<div class="panel-empty" style="color: var(--bad-fg);">Failed: '+escapeHtml(J.message)+"</div>"}}}async function p(){if(d){d.innerHTML='<div class="panel-empty"><span class="brand-spinner"></span> Loading...</div>';try{var e=await fetch("/api/v1/backups/history?limit=50"),s=await e.json();if(!s.success||!s.history?.length){d.innerHTML='<div class="panel-empty"><span class="empty-icon">\u{1F4CB}</span> No backup history yet</div>';return}for(var n='<div style="display: flex; flex-direction: column; gap: 6px;">',r=0;r<s.history.length;r++){var a=s.history[r],i=a.size?(a.size/1024/1024).toFixed(2):"?";n+='<div style="padding: 10px 12px; background: var(--card-base); border-radius: 6px; border: 1px solid var(--border); font-size: 0.85rem;">',n+='  <div style="display: flex; justify-content: space-between; align-items: center; margin-bottom: 4px;">',n+='    <span style="font-weight: 500;">'+escapeHtml(a.name||"backup")+"</span>",n+='    <div style="display: flex; align-items: center; gap: 8px;">',n+='      <span class="status-badge '+(a.status==="success"?"success":"down")+'">'+escapeHtml(a.status)+"</span>",a.status==="success"&&(n+='      <button class="backup-restore-btn" data-backup-id="'+escapeHtml(a.id)+'" style="padding: 3px 8px; font-size: 0.75rem;">Restore</button>'),n+="    </div>",n+="  </div>",n+='  <div style="font-size: 0.75rem; color: var(--muted);">',n+="    "+new Date(a.timestamp).toLocaleString()+" | "+i+" MB | "+(a.duration?(a.duration/1e3).toFixed(1)+"s":"--"),a.encrypted&&(n+=" | \u{1F512}"),n+="  </div>",n+="</div>"}n+="</div>",d.innerHTML=n,d.querySelectorAll(".backup-restore-btn").forEach(function(c){c.addEventListener("click",function(){window.__restoreServerBackup(c.dataset.backupId)})})}catch(c){d.innerHTML='<div class="panel-empty" style="color: var(--bad-fg);">Failed: '+escapeHtml(c.message)+"</div>"}}}window.__restoreServerBackup=async function(e){if(confirm("Restore from this server backup? This will overwrite current configuration."))try{var s=await secureFetch("/api/v1/backups/restore/"+e,{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify({restoreServices:!0,restoreConfig:!0})}),n=await s.json();n.success?(showNotification("Restore completed successfully!","success"),location.reload()):showNotification("Restore failed: "+(n.error||"Unknown error"),"error")}catch(r){showNotification("Restore error: "+r.message,"error")}},document.querySelector('[data-panel="backup-schedules-tab"]')?.addEventListener("click",m),document.querySelector('[data-panel="backup-disk-tab"]')?.addEventListener("click",o),document.querySelector('[data-panel="backup-pointintime-tab"]')?.addEventListener("click",l),document.querySelector('[data-panel="backup-history-tab"]')?.addEventListener("click",p);async function l(){if(S){try{var e=await fetch("/api/v1/license/status"),s=await e.json();if(s.tier!=="premium"){S.innerHTML=`<div class="panel-empty" style="padding: 24px; text-align: center;"><div style="font-size: 2rem; margin-bottom: 12px;">\u2B50</div><div style="font-weight: 600; margin-bottom: 8px;">Premium Feature</div><div style="font-size: 0.85rem; color: var(--muted);">Point-in-time restore requires DashCaddy Premium with auto-backup enabled.</div><button onclick="showNotification('Upgrade to Premium for point-in-time restore!', 'info'); scrollToSection('license');" style="margin-top: 16px; padding: 8px 20px; background: linear-gradient(135deg, #f39c12, #e67e22); border: none; color: white; border-radius: 8px; cursor: pointer; font-weight: 600;">Upgrade to Premium</button></div>`;return}}catch{}S.innerHTML='<div class="panel-empty"><span class="brand-spinner"></span> Loading...</div>';try{var n=await fetch("/api/v1/services"),r=await n.json(),a=r.services||[];if(a.length===0){S.innerHTML='<div class="panel-empty"><span class="empty-icon">\u{1F4E6}</span> No apps deployed yet</div>';return}for(var i='<div style="padding: 8px 0 12px;"><div style="display: flex; gap: 8px; align-items: center; margin-bottom: 12px;">  <label style="font-size: 0.85rem; color: var(--muted); white-space: nowrap;">App:</label>  <select id="pit-app-select" style="flex: 1; padding: 8px; border-radius: 6px; border: 1px solid var(--border); background: var(--base); max-width: 240px;">',c=0;c<a.length;c++)i+='<option value="'+escapeHtml(a[c].id||a[c].name||"")+'">'+escapeHtml(a[c].name||a[c].id||"")+"</option>";i+='</select>  <button id="pit-load-btn" style="padding: 8px 16px; background: var(--accent); border: none; color: white; border-radius: 6px; cursor: pointer; font-weight: 500;">Load Backups</button></div><div id="pit-backups-list" style="max-height: 320px; overflow-y: auto;"></div></div>',S.innerHTML=i,document.getElementById("pit-load-btn")?.addEventListener("click",function(){var I=document.getElementById("pit-app-select")?.value;I&&y(I)})}catch(I){S.innerHTML='<div class="panel-empty" style="color: var(--bad-fg);">Failed: '+escapeHtml(I.message)+"</div>"}}}async function y(e){var s=document.getElementById("pit-backups-list");if(s){s.innerHTML='<div style="padding: 20px; text-align: center;"><span class="brand-spinner"></span> Loading backups...</div>';try{var n=await fetch("/api/v1/backups/files/"+encodeURIComponent(e)),r=await n.json();if(!r.success||!r.files||r.files.length===0){s.innerHTML='<div class="panel-empty"><span class="empty-icon">\u{1F4BE}</span> No backup files for '+escapeHtml(e)+"</div>";return}for(var a='<div style="font-size: 0.75rem; color: var(--muted); margin-bottom: 8px;">'+r.files.length+' backup(s)</div><div style="display: flex; flex-direction: column; gap: 6px;">',i=0;i<r.files.length;i++){var c=r.files[i],I=new Date(c.timestamp).toLocaleString();a+='<div style="padding: 10px 12px; background: var(--card-base); border-radius: 8px; border: 1px solid var(--border);"><div style="display: flex; justify-content: space-between; align-items: center; margin-bottom: 4px;">  <div style="font-weight: 500; font-size: 0.85rem;">'+escapeHtml(c.name)+'</div>  <div style="font-size: 0.75rem; color: var(--muted);">'+c.sizeFormatted+'</div></div><div style="font-size: 0.75rem; color: var(--muted); margin-bottom: 8px;">'+I+'</div><div style="display: flex; gap: 6px;">  <button class="pit-compare-btn" data-appid="'+escapeHtml(e)+'" data-filename="'+escapeHtml(c.name)+'" style="padding: 4px 10px; font-size: 0.75rem; background: transparent; border: 1px solid var(--accent); color: var(--accent); border-radius: 5px; cursor: pointer;">Compare</button>  <button class="pit-restore-btn" data-appid="'+escapeHtml(e)+'" data-filename="'+escapeHtml(c.name)+'" style="padding: 4px 10px; font-size: 0.75rem; background: linear-gradient(135deg, var(--ok-fg), #27ae60); border: none; color: white; border-radius: 5px; cursor: pointer; font-weight: 500;">Restore</button></div></div>'}a+="</div>",s.innerHTML=a,s.querySelectorAll(".pit-compare-btn").forEach(function(N){N.addEventListener("click",function(){u(N.dataset.appid,N.dataset.filename)})}),s.querySelectorAll(".pit-restore-btn").forEach(function(N){N.addEventListener("click",function(){t(N.dataset.appid,N.dataset.filename)})})}catch(N){s.innerHTML='<div class="panel-empty" style="color: var(--bad-fg);">Failed: '+escapeHtml(N.message)+"</div>"}}}async function u(e,s){try{var n=await secureFetch("/api/v1/backups/compare/"+encodeURIComponent(s),{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify({})}),r=await n.json();if(!r.success){showNotification("Compare failed: "+(r.error||"Unknown"),"error");return}var a=r.diff,i='<div style="position: fixed; top: 0; left: 0; right: 0; bottom: 0; background: rgba(0,0,0,0.5); z-index: 10000; display: flex; align-items: center; justify-content: center;" id="compare-overlay"><div style="background: var(--base); border-radius: 12px; max-width: 600px; width: 90%; max-height: 80vh; overflow: auto; padding: 20px; border: 1px solid var(--border);"><h4 style="margin: 0 0 16px;">\u{1F4CA} Compare: '+escapeHtml(s)+'</h4><div style="font-size: 0.8rem; color: var(--muted); margin-bottom: 16px;">Size: '+(a.sizeFormatted||"?")+" | Created: "+new Date(a.timestamp).toLocaleString()+"</div>";if(a.services){var c=a.services.hasChanges?"\u{1F534}":"\u{1F7E2}";i+='<div style="margin-bottom: 12px; padding: 10px; background: var(--card-base); border-radius: 6px; border: 1px solid var(--border);"><div style="font-weight: 600; font-size: 0.85rem; margin-bottom: 4px;">'+c+' Services (backup vs current)</div><div style="font-size: 0.8rem; color: var(--muted);">Backup: '+a.services.backupCount+" services | Current: "+a.services.currentCount+" services</div>",a.services.hasChanges&&(i+='<div style="margin-top: 6px; font-size: 0.8rem; color: #f39c12;">Services differ \u2014 restoring will replace current configuration</div>'),i+="</div>"}if(a.config){var I=a.config.hasChanges?"\u{1F534}":"\u{1F7E2}";i+='<div style="margin-bottom: 12px; padding: 10px; background: var(--card-base); border-radius: 6px; border: 1px solid var(--border);"><div style="font-weight: 600; font-size: 0.85rem; margin-bottom: 4px;">'+I+" Configuration</div>",a.config.hasChanges?i+='<div style="font-size: 0.8rem; color: #f39c12;">Configuration differs \u2014 restoring will replace current settings</div>':i+='<div style="font-size: 0.8rem; color: var(--ok-fg);">No changes</div>',i+="</div>"}i+='<button id="compare-close-btn" style="padding: 8px 20px; background: var(--accent); border: none; color: white; border-radius: 6px; cursor: pointer; font-weight: 500;">Close</button></div></div>',document.body.insertAdjacentHTML("beforeend",i),document.getElementById("compare-close-btn")?.addEventListener("click",function(){document.getElementById("compare-overlay")?.remove()}),document.getElementById("compare-overlay")?.addEventListener("click",function(N){N.target===this&&this.remove()})}catch(N){showNotification("Compare error: "+N.message,"error")}}async function t(e,s){if(confirm("Restore "+s+" for "+e+`?
+  </div>`);var A=document.getElementById("backup-modal"),D=document.getElementById("backup-restore-btn"),R=document.getElementById("backup-cancel"),y=document.getElementById("backup-export-btn"),$=document.getElementById("backup-select-file"),k=document.getElementById("backup-file-input"),H=document.getElementById("backup-file-name"),T=document.getElementById("backup-preview"),z=document.getElementById("backup-preview-content"),C=document.getElementById("backup-do-restore-btn"),M=document.getElementById("backup-result"),b=document.getElementById("backup-schedules-container"),d=document.getElementById("backup-history-container"),v=document.getElementById("backup-disk-container"),S=document.getElementById("pointintime-container"),O=null;D?.addEventListener("click",function(){A.classList.add("show"),M&&(M.style.display="none"),T&&(T.style.display="none"),H&&(H.style.display="none"),O=null}),wireModal(A,R),y?.addEventListener("click",async function(){y.disabled=!0,y.innerHTML='<span class="brand-spinner"></span> Exporting...';try{var e=await fetch("/api/v1/backup/export"),s=await e.json();s.browserState=E();var n=new Blob([JSON.stringify(s,null,2)],{type:"application/json"}),r=URL.createObjectURL(n),a=document.createElement("a");a.href=r,a.download="dashcaddy-backup-"+new Date().toISOString().split("T")[0]+".json",document.body.appendChild(a),a.click(),document.body.removeChild(a),URL.revokeObjectURL(r);var i=Object.keys(s.browserState).length,c=s.themes?Object.keys(s.themes).length:0;M.innerHTML="\u2705 Full backup downloaded \u2014 server config + "+i+" browser settings"+(c?" + "+c+" themes":""),M.style.display="block",M.style.background="color-mix(in srgb, var(--ok-fg) 15%, transparent)",M.style.border="1px solid var(--ok-fg)"}catch(I){M.innerHTML="\u274C Export failed: "+escapeHtml(I.message),M.style.display="block",M.style.background="color-mix(in srgb, var(--bad-fg) 15%, transparent)",M.style.border="1px solid var(--bad-fg)"}y.disabled=!1,y.innerHTML="\u2B07\uFE0F Download Full Backup"}),$?.addEventListener("click",function(){k.click()}),k?.addEventListener("change",async function(e){var s=e.target.files[0];if(s){H.textContent="\u{1F4C4} "+s.name,H.style.display="block",M.style.display="none";try{var n=await s.text(),r=JSON.parse(n);if(h(r)){O=r;var a='<div style="margin-bottom: 8px; color: var(--muted); font-size: 0.8rem;">Legacy format (v'+escapeHtml(r.version)+")</div>";a+='<div style="display: flex; flex-wrap: wrap; gap: 6px;">',r.services?.length&&(a+='<span style="padding: 4px 8px; background: var(--base); border-radius: 4px; font-size: 0.8rem;">\u{1F4CB} '+r.services.length+" services</span>"),r.customApps?.length&&(a+='<span style="padding: 4px 8px; background: var(--base); border-radius: 4px; font-size: 0.8rem;">\u{1F4E6} '+r.customApps.length+" custom apps</span>"),r.theme&&(a+='<span style="padding: 4px 8px; background: var(--base); border-radius: 4px; font-size: 0.8rem;">\u{1F3A8} Theme: '+escapeHtml(r.theme)+"</span>"),r.userThemes&&(a+='<span style="padding: 4px 8px; background: var(--base); border-radius: 4px; font-size: 0.8rem;">\u{1F3A8} '+Object.keys(r.userThemes).length+" custom themes</span>"),a+="</div>",z.innerHTML=a,T.style.display="block";return}var i=await secureFetch("/api/v1/backup/preview",{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify(r)}),c=await i.json();if(c.success){O=r;var a='<div style="margin-bottom: 8px; color: var(--muted); font-size: 0.8rem;">Exported: '+new Date(r.exportedAt).toLocaleString()+" (v"+escapeHtml(r.version)+")</div>";a+='<div style="margin-bottom: 6px; font-size: 0.75rem; color: var(--muted); text-transform: uppercase; letter-spacing: 0.5px;">Server Config</div>',a+='<div style="display: flex; flex-wrap: wrap; gap: 6px; margin-bottom: 10px;">';for(var I in c.preview.files){var N=c.preview.files[I],U=N.action==="create"?"\u{1F195}":"\u{1F4DD}";a+='<span style="padding: 4px 8px; background: var(--base); border-radius: 4px; font-size: 0.8rem;">'+U+" "+escapeHtml(N.description)+"</span>"}a+="</div>",c.preview.serviceCount&&(a+='<div style="font-size: 0.8rem; color: var(--accent); margin-bottom: 6px;">'+c.preview.serviceCount+" services</div>"),c.preview.themeCount&&(a+='<div style="font-size: 0.8rem; color: var(--accent); margin-bottom: 6px;">\u{1F3A8} '+c.preview.themeCount+" custom themes</div>"),c.preview.browserStateCount&&(a+='<div style="margin-top: 6px; font-size: 0.75rem; color: var(--muted); text-transform: uppercase; letter-spacing: 0.5px;">Browser Preferences</div>',a+='<div style="font-size: 0.8rem; color: var(--accent);">\u{1F5A5}\uFE0F '+c.preview.browserStateCount+" saved settings (theme, weather, clock, widgets, etc.)</div>"),z.innerHTML=a,T.style.display="block"}else M.innerHTML="\u26A0\uFE0F Invalid backup file: "+escapeHtml(c.error),M.style.display="block",M.style.background="color-mix(in srgb, #f39c12 15%, transparent)",M.style.border="1px solid #f39c12",T.style.display="none"}catch(_){M.innerHTML="\u274C Could not read file: "+escapeHtml(_.message),M.style.display="block",M.style.background="color-mix(in srgb, var(--bad-fg) 15%, transparent)",M.style.border="1px solid var(--bad-fg)",T.style.display="none"}}}),C?.addEventListener("click",async function(){if(O&&confirm("This will overwrite your current configuration and browser preferences. Continue?")){C.disabled=!0,C.innerHTML='<span class="brand-spinner"></span> Restoring...';try{if(h(O)){P(O),M.innerHTML="\u2705 Legacy backup restored \u2014 browser settings and services imported.",M.style.background="color-mix(in srgb, var(--ok-fg) 15%, transparent)",M.style.border="1px solid var(--ok-fg)",M.style.display="block",setTimeout(function(){location.reload()},2e3),C.disabled=!1,C.innerHTML="\u26A1 Restore Everything";return}var e=document.getElementById("backup-reload-caddy")?.checked??!0,s=await secureFetch("/api/v1/backup/restore",{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify({backup:O,options:{reloadCaddy:e}})}),n=await s.json(),r=0;if(O.browserState&&(r=j(O.browserState)),n.success){var a="\u2705 "+n.message;r>0&&(a+='<br><small style="color: var(--muted);">'+r+" browser settings restored</small>"),n.results.caddyReloaded&&(a+='<br><small style="color: var(--muted);">Caddy configuration reloaded</small>'),M.innerHTML=a,M.style.background="color-mix(in srgb, var(--ok-fg) 15%, transparent)",M.style.border="1px solid var(--ok-fg)",setTimeout(function(){location.reload()},2e3)}else M.innerHTML="\u26A0\uFE0F "+escapeHtml(n.message),r>0&&(M.innerHTML+='<br><small style="color: var(--muted);">'+r+" browser settings were restored</small>"),n.results?.errors?.length>0&&(M.innerHTML+="<br><small>"+n.results.errors.map(function(i){return escapeHtml(i.file)+": "+escapeHtml(i.error)}).join(", ")+"</small>"),M.style.background="color-mix(in srgb, #f39c12 15%, transparent)",M.style.border="1px solid #f39c12";M.style.display="block"}catch(i){M.innerHTML="\u274C Restore failed: "+escapeHtml(i.message),M.style.display="block",M.style.background="color-mix(in srgb, var(--bad-fg) 15%, transparent)",M.style.border="1px solid var(--bad-fg)"}C.disabled=!1,C.innerHTML="\u26A1 Restore Everything"}});async function m(){if(b){b.innerHTML='<div class="panel-empty"><span class="brand-spinner"></span> Loading...</div>';try{var e=await fetch("/api/v1/backups/schedule"),s=await e.json();if(s.premiumRequired){b.innerHTML=`<div class="panel-empty" style="padding: 24px; text-align: center;"><div style="font-size: 2rem; margin-bottom: 12px;">\u2B50</div><div style="font-weight: 600; margin-bottom: 8px;">Premium Feature</div><div style="font-size: 0.85rem; color: var(--muted);">Auto-backup scheduling requires a DashCaddy Premium subscription.</div><button onclick="showNotification('Upgrade to Premium to enable auto-backups!', 'info'); scrollToSection('license');" style="margin-top: 16px; padding: 8px 20px; background: linear-gradient(135deg, #f39c12, #e67e22); border: none; color: white; border-radius: 8px; cursor: pointer; font-weight: 600;">Upgrade to Premium</button></div>`;return}if(!s.success)throw new Error(s.error||"Failed to load schedules");var n=s.schedules||[];if(n.length===0){b.innerHTML='<div class="panel-empty"><span class="empty-icon">\u23F0</span><div>No backup schedules configured</div><div style="font-size: 0.8rem; color: var(--muted); margin-top: 4px;">Select apps below to enable auto-backup</div></div>';return}for(var r='<div style="display: flex; flex-direction: column; gap: 8px;">',a=0;a<n.length;a++){var i=n[a],c=i.nextRun?new Date(i.nextRun).toLocaleString():"Not scheduled",I=i.lastRun?new Date(i.lastRun).toLocaleString():"Never";r+='<div style="padding: 12px 14px; background: var(--card-base); border-radius: 8px; border: 1px solid var(--border);"><div style="display: flex; justify-content: space-between; align-items: center; margin-bottom: 8px;">  <div style="font-weight: 600; font-size: 0.9rem;">'+escapeHtml(i.appId)+'</div>  <label class="toggle-switch" style="display: flex; align-items: center; gap: 6px;">    <input type="checkbox" class="schedule-toggle" data-appid="'+escapeHtml(i.appId)+'"'+(i.enabled?" checked":"")+' />    <span style="font-size: 0.75rem; color: var(--muted);">'+(i.enabled?"ON":"OFF")+'</span>  </label></div><div style="display: grid; grid-template-columns: 1fr 1fr; gap: 8px; font-size: 0.8rem; margin-bottom: 10px;">  <div><span style="color: var(--muted);">Schedule:</span> <select class="schedule-select" data-appid="'+escapeHtml(i.appId)+'" style="background: var(--base); border: 1px solid var(--border); border-radius: 4px; padding: 2px 6px;">    <option value="hourly"'+(i.schedule==="hourly"?" selected":"")+'>Hourly</option>    <option value="daily"'+(i.schedule==="daily"?" selected":"")+'>Daily</option>    <option value="weekly"'+(i.schedule==="weekly"?" selected":"")+'>Weekly</option>    <option value="monthly"'+(i.schedule==="monthly"?" selected":"")+'>Monthly</option>  </select></div>  <div><span style="color: var(--muted);">Keep last:</span> <input type="number" class="retention-input" data-appid="'+escapeHtml(i.appId)+'" value="'+(i.retention?.keep||7)+'" min="1" max="100" style="width: 50px; background: var(--base); border: 1px solid var(--border); border-radius: 4px; padding: 2px 6px;" /></div></div><div style="font-size: 0.75rem; color: var(--muted); margin-bottom: 10px;">  <div>Next run: '+escapeHtml(c)+"</div>  <div>Last run: "+escapeHtml(I)+'</div></div><div style="display: flex; gap: 6px;">  <button class="schedule-run-now" data-appid="'+escapeHtml(i.appId)+'" style="padding: 5px 12px; font-size: 0.8rem; background: color-mix(in srgb, var(--ok-fg) 20%, transparent); border: 1px solid var(--ok-fg); color: var(--ok-fg); border-radius: 6px; cursor: pointer;">\u25B6\uFE0F Run Now</button>  <button class="schedule-delete" data-appid="'+escapeHtml(i.appId)+'" style="padding: 5px 12px; font-size: 0.8rem; background: transparent; border: 1px solid var(--bad-fg); color: var(--bad-fg); border-radius: 6px; cursor: pointer;">\u{1F5D1}\uFE0F Remove</button></div></div>'}r+="</div>",r+='<div style="margin-top: 16px; padding: 16px; background: color-mix(in srgb, var(--accent) 5%, transparent); border-radius: 10px; border: 1px dashed var(--border);"><h4 style="margin: 0 0 12px; font-size: 0.85rem; color: var(--muted);">\u2795 Add New Schedule</h4><div style="display: flex; gap: 8px; flex-wrap: wrap;">  <input type="text" id="new-schedule-appid" placeholder="App ID (e.g., plex, sonarr)" style="flex: 1; min-width: 150px; padding: 8px; border-radius: 6px; border: 1px solid var(--border); background: var(--base);" />  <select id="new-schedule-interval" style="padding: 8px; border-radius: 6px; border: 1px solid var(--border); background: var(--base);">    <option value="hourly">Hourly</option>    <option value="daily" selected>Daily</option>    <option value="weekly">Weekly</option>    <option value="monthly">Monthly</option>    <option value="6h">Every 6 hours</option>    <option value="30m">Every 30 minutes</option>  </select>  <input type="number" id="new-schedule-retention" value="7" min="1" max="100" placeholder="Keep" style="width: 70px; padding: 8px; border-radius: 6px; border: 1px solid var(--border); background: var(--base);" />  <button id="add-schedule-btn" style="padding: 8px 16px; background: var(--accent); border: none; color: white; border-radius: 6px; cursor: pointer; font-weight: 500;">Add Schedule</button></div></div>',b.innerHTML=r,b.querySelectorAll(".schedule-toggle").forEach(function(N){N.addEventListener("change",function(){f(N.dataset.appid,{enabled:N.checked})})}),b.querySelectorAll(".schedule-select").forEach(function(N){N.addEventListener("change",function(){f(N.dataset.appid,{schedule:N.value})})}),b.querySelectorAll(".retention-input").forEach(function(N){N.addEventListener("change",function(){f(N.dataset.appid,{retention:{keep:parseInt(N.value)||7}})})}),b.querySelectorAll(".schedule-run-now").forEach(function(N){N.addEventListener("click",function(){B(N.dataset.appid)})}),b.querySelectorAll(".schedule-delete").forEach(function(N){N.addEventListener("click",function(){w(N.dataset.appid)})}),document.getElementById("add-schedule-btn")?.addEventListener("click",L)}catch(N){b.innerHTML='<div class="panel-empty" style="color: var(--bad-fg);">Failed to load: '+escapeHtml(N.message)+"</div>"}}}async function f(e,s){try{var n=await secureFetch("/api/v1/backups/schedule",{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify({appId:e,...s})}),r=await n.json();r.success?showNotification("Schedule updated for "+e,"success"):(showNotification("Update failed: "+(r.error||"Unknown"),"error"),m())}catch(a){showNotification("Error: "+a.message,"error")}}async function B(e){try{var s=await secureFetch("/api/v1/backups/backup/"+encodeURIComponent(e),{method:"POST",headers:{"Content-Type":"application/json"}}),n=await s.json();n.success?showNotification("Backup started for "+e+"!","success"):showNotification("Backup failed: "+(n.error||"Unknown"),"error")}catch(r){showNotification("Error: "+r.message,"error")}}async function w(e){if(confirm("Remove backup schedule for "+e+"?"))try{var s=await secureFetch("/api/v1/backups/schedule/"+encodeURIComponent(e),{method:"DELETE"}),n=await s.json();n.success?(showNotification("Schedule removed for "+e,"success"),m()):showNotification("Delete failed: "+(n.error||"Unknown"),"error")}catch(r){showNotification("Error: "+r.message,"error")}}async function L(){var e=document.getElementById("new-schedule-appid")?.value?.trim(),s=document.getElementById("new-schedule-interval")?.value||"daily",n=parseInt(document.getElementById("new-schedule-retention")?.value)||7;if(!e){showNotification("Please enter an App ID","warning");return}try{var r=await secureFetch("/api/v1/backups/schedule",{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify({appId:e,schedule:s,retention:{keep:n},enabled:!0})}),a=await r.json();if(a.success){showNotification("Schedule created for "+e,"success"),m();var i=document.getElementById("new-schedule-appid");i&&(i.value="")}else showNotification("Failed: "+(a.error||"Unknown"),"error")}catch(c){showNotification("Error: "+c.message,"error")}}async function o(){if(v){v.innerHTML='<div class="panel-empty"><span class="brand-spinner"></span> Loading...</div>';try{var e=await fetch("/api/v1/backups/files"),s=await e.json();if(!s.success)throw new Error(s.error||"Failed to load");var n=s.files||[];if(n.length===0){v.innerHTML='<div class="panel-empty"><span class="empty-icon">\u{1F4BE}</span><div>No backup files on disk</div><div style="font-size: 0.8rem; color: var(--muted); margin-top: 4px;">Run a backup to create backup files</div></div>';return}for(var r={},a=0;a<n.length;a++){var i=n[a],c=i.appId||"unknown";r[c]||(r[c]=[]),r[c].push(i)}var I='<div style="font-size: 0.75rem; color: var(--muted); margin-bottom: 12px;">'+n.length+" backup file(s) across "+Object.keys(r).length+" app(s)</div>";I+='<div style="display: flex; flex-direction: column; gap: 12px;">';for(var N=Object.keys(r).sort(),U=0;U<N.length;U++){var c=N[U],_=r[c];I+='<div style="background: var(--card-base); border-radius: 8px; border: 1px solid var(--border); overflow: hidden;"><div style="padding: 8px 12px; background: color-mix(in srgb, var(--accent) 8%, transparent); border-bottom: 1px solid var(--border); font-weight: 600; font-size: 0.85rem;">'+escapeHtml(c)+' <span style="font-weight: normal; color: var(--muted); font-size: 0.75rem;">('+_.length+" backup(s))</span></div>";for(var F=0;F<_.length;F++){var i=_[F],q=new Date(i.timestamp).toLocaleString();I+='<div style="padding: 10px 12px; border-bottom: 1px solid var(--border);"><div style="display: flex; justify-content: space-between; align-items: center; margin-bottom: 4px;">  <div style="font-weight: 500; font-size: 0.85rem;">'+escapeHtml(i.name)+'</div>  <div style="font-size: 0.75rem; color: var(--muted);">'+i.sizeFormatted+'</div></div><div style="font-size: 0.75rem; color: var(--muted); margin-bottom: 8px;">'+q+'</div><div style="display: flex; gap: 6px;">  <button class="disk-compare-btn" data-appid="'+escapeHtml(c)+'" data-filename="'+escapeHtml(i.name)+'" style="padding: 3px 8px; font-size: 0.75rem; background: transparent; border: 1px solid var(--accent); color: var(--accent); border-radius: 5px; cursor: pointer;">Compare</button>  <button class="disk-restore-btn" data-appid="'+escapeHtml(c)+'" data-filename="'+escapeHtml(i.name)+'" style="padding: 3px 8px; font-size: 0.75rem; background: linear-gradient(135deg, var(--ok-fg), #27ae60); border: none; color: white; border-radius: 5px; cursor: pointer; font-weight: 500;">Restore</button></div></div>'}I+="</div>"}I+="</div>",v.innerHTML=I,v.querySelectorAll(".disk-compare-btn").forEach(function(J){J.addEventListener("click",function(){p(J.dataset.appid,J.dataset.filename)})}),v.querySelectorAll(".disk-restore-btn").forEach(function(J){J.addEventListener("click",function(){t(J.dataset.appid,J.dataset.filename)})})}catch(J){v.innerHTML='<div class="panel-empty" style="color: var(--bad-fg);">Failed: '+escapeHtml(J.message)+"</div>"}}}async function u(){if(d){d.innerHTML='<div class="panel-empty"><span class="brand-spinner"></span> Loading...</div>';try{var e=await fetch("/api/v1/backups/history?limit=50"),s=await e.json();if(!s.success||!s.history?.length){d.innerHTML='<div class="panel-empty"><span class="empty-icon">\u{1F4CB}</span> No backup history yet</div>';return}for(var n='<div style="display: flex; flex-direction: column; gap: 6px;">',r=0;r<s.history.length;r++){var a=s.history[r],i=a.size?(a.size/1024/1024).toFixed(2):"?";n+='<div style="padding: 10px 12px; background: var(--card-base); border-radius: 6px; border: 1px solid var(--border); font-size: 0.85rem;">',n+='  <div style="display: flex; justify-content: space-between; align-items: center; margin-bottom: 4px;">',n+='    <span style="font-weight: 500;">'+escapeHtml(a.name||"backup")+"</span>",n+='    <div style="display: flex; align-items: center; gap: 8px;">',n+='      <span class="status-badge '+(a.status==="success"?"success":"down")+'">'+escapeHtml(a.status)+"</span>",a.status==="success"&&(n+='      <button class="backup-restore-btn" data-backup-id="'+escapeHtml(a.id)+'" style="padding: 3px 8px; font-size: 0.75rem;">Restore</button>'),n+="    </div>",n+="  </div>",n+='  <div style="font-size: 0.75rem; color: var(--muted);">',n+="    "+new Date(a.timestamp).toLocaleString()+" | "+i+" MB | "+(a.duration?(a.duration/1e3).toFixed(1)+"s":"--"),a.encrypted&&(n+=" | \u{1F512}"),n+="  </div>",n+="</div>"}n+="</div>",d.innerHTML=n,d.querySelectorAll(".backup-restore-btn").forEach(function(c){c.addEventListener("click",function(){window.__restoreServerBackup(c.dataset.backupId)})})}catch(c){d.innerHTML='<div class="panel-empty" style="color: var(--bad-fg);">Failed: '+escapeHtml(c.message)+"</div>"}}}window.__restoreServerBackup=async function(e){if(confirm("Restore from this server backup? This will overwrite current configuration."))try{var s=await secureFetch("/api/v1/backups/restore/"+e,{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify({restoreServices:!0,restoreConfig:!0})}),n=await s.json();n.success?(showNotification("Restore completed successfully!","success"),location.reload()):showNotification("Restore failed: "+(n.error||"Unknown error"),"error")}catch(r){showNotification("Restore error: "+r.message,"error")}},document.querySelector('[data-panel="backup-schedules-tab"]')?.addEventListener("click",m),document.querySelector('[data-panel="backup-disk-tab"]')?.addEventListener("click",o),document.querySelector('[data-panel="backup-pointintime-tab"]')?.addEventListener("click",l),document.querySelector('[data-panel="backup-history-tab"]')?.addEventListener("click",u);async function l(){if(S){try{var e=await fetch("/api/v1/license/status"),s=await e.json();if(s.tier!=="premium"){S.innerHTML=`<div class="panel-empty" style="padding: 24px; text-align: center;"><div style="font-size: 2rem; margin-bottom: 12px;">\u2B50</div><div style="font-weight: 600; margin-bottom: 8px;">Premium Feature</div><div style="font-size: 0.85rem; color: var(--muted);">Point-in-time restore requires DashCaddy Premium with auto-backup enabled.</div><button onclick="showNotification('Upgrade to Premium for point-in-time restore!', 'info'); scrollToSection('license');" style="margin-top: 16px; padding: 8px 20px; background: linear-gradient(135deg, #f39c12, #e67e22); border: none; color: white; border-radius: 8px; cursor: pointer; font-weight: 600;">Upgrade to Premium</button></div>`;return}}catch{}S.innerHTML='<div class="panel-empty"><span class="brand-spinner"></span> Loading...</div>';try{var n=await fetch("/api/v1/services"),r=await n.json(),a=r.services||[];if(a.length===0){S.innerHTML='<div class="panel-empty"><span class="empty-icon">\u{1F4E6}</span> No apps deployed yet</div>';return}for(var i='<div style="padding: 8px 0 12px;"><div style="display: flex; gap: 8px; align-items: center; margin-bottom: 12px;">  <label style="font-size: 0.85rem; color: var(--muted); white-space: nowrap;">App:</label>  <select id="pit-app-select" style="flex: 1; padding: 8px; border-radius: 6px; border: 1px solid var(--border); background: var(--base); max-width: 240px;">',c=0;c<a.length;c++)i+='<option value="'+escapeHtml(a[c].id||a[c].name||"")+'">'+escapeHtml(a[c].name||a[c].id||"")+"</option>";i+='</select>  <button id="pit-load-btn" style="padding: 8px 16px; background: var(--accent); border: none; color: white; border-radius: 6px; cursor: pointer; font-weight: 500;">Load Backups</button></div><div id="pit-backups-list" style="max-height: 320px; overflow-y: auto;"></div></div>',S.innerHTML=i,document.getElementById("pit-load-btn")?.addEventListener("click",function(){var I=document.getElementById("pit-app-select")?.value;I&&g(I)})}catch(I){S.innerHTML='<div class="panel-empty" style="color: var(--bad-fg);">Failed: '+escapeHtml(I.message)+"</div>"}}}async function g(e){var s=document.getElementById("pit-backups-list");if(s){s.innerHTML='<div style="padding: 20px; text-align: center;"><span class="brand-spinner"></span> Loading backups...</div>';try{var n=await fetch("/api/v1/backups/files/"+encodeURIComponent(e)),r=await n.json();if(!r.success||!r.files||r.files.length===0){s.innerHTML='<div class="panel-empty"><span class="empty-icon">\u{1F4BE}</span> No backup files for '+escapeHtml(e)+"</div>";return}for(var a='<div style="font-size: 0.75rem; color: var(--muted); margin-bottom: 8px;">'+r.files.length+' backup(s)</div><div style="display: flex; flex-direction: column; gap: 6px;">',i=0;i<r.files.length;i++){var c=r.files[i],I=new Date(c.timestamp).toLocaleString();a+='<div style="padding: 10px 12px; background: var(--card-base); border-radius: 8px; border: 1px solid var(--border);"><div style="display: flex; justify-content: space-between; align-items: center; margin-bottom: 4px;">  <div style="font-weight: 500; font-size: 0.85rem;">'+escapeHtml(c.name)+'</div>  <div style="font-size: 0.75rem; color: var(--muted);">'+c.sizeFormatted+'</div></div><div style="font-size: 0.75rem; color: var(--muted); margin-bottom: 8px;">'+I+'</div><div style="display: flex; gap: 6px;">  <button class="pit-compare-btn" data-appid="'+escapeHtml(e)+'" data-filename="'+escapeHtml(c.name)+'" style="padding: 4px 10px; font-size: 0.75rem; background: transparent; border: 1px solid var(--accent); color: var(--accent); border-radius: 5px; cursor: pointer;">Compare</button>  <button class="pit-restore-btn" data-appid="'+escapeHtml(e)+'" data-filename="'+escapeHtml(c.name)+'" style="padding: 4px 10px; font-size: 0.75rem; background: linear-gradient(135deg, var(--ok-fg), #27ae60); border: none; color: white; border-radius: 5px; cursor: pointer; font-weight: 500;">Restore</button></div></div>'}a+="</div>",s.innerHTML=a,s.querySelectorAll(".pit-compare-btn").forEach(function(N){N.addEventListener("click",function(){p(N.dataset.appid,N.dataset.filename)})}),s.querySelectorAll(".pit-restore-btn").forEach(function(N){N.addEventListener("click",function(){t(N.dataset.appid,N.dataset.filename)})})}catch(N){s.innerHTML='<div class="panel-empty" style="color: var(--bad-fg);">Failed: '+escapeHtml(N.message)+"</div>"}}}async function p(e,s){try{var n=await secureFetch("/api/v1/backups/compare/"+encodeURIComponent(s),{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify({})}),r=await n.json();if(!r.success){showNotification("Compare failed: "+(r.error||"Unknown"),"error");return}var a=r.diff,i='<div style="position: fixed; top: 0; left: 0; right: 0; bottom: 0; background: rgba(0,0,0,0.5); z-index: 10000; display: flex; align-items: center; justify-content: center;" id="compare-overlay"><div style="background: var(--base); border-radius: 12px; max-width: 600px; width: 90%; max-height: 80vh; overflow: auto; padding: 20px; border: 1px solid var(--border);"><h4 style="margin: 0 0 16px;">\u{1F4CA} Compare: '+escapeHtml(s)+'</h4><div style="font-size: 0.8rem; color: var(--muted); margin-bottom: 16px;">Size: '+(a.sizeFormatted||"?")+" | Created: "+new Date(a.timestamp).toLocaleString()+"</div>";if(a.services){var c=a.services.hasChanges?"\u{1F534}":"\u{1F7E2}";i+='<div style="margin-bottom: 12px; padding: 10px; background: var(--card-base); border-radius: 6px; border: 1px solid var(--border);"><div style="font-weight: 600; font-size: 0.85rem; margin-bottom: 4px;">'+c+' Services (backup vs current)</div><div style="font-size: 0.8rem; color: var(--muted);">Backup: '+a.services.backupCount+" services | Current: "+a.services.currentCount+" services</div>",a.services.hasChanges&&(i+='<div style="margin-top: 6px; font-size: 0.8rem; color: #f39c12;">Services differ \u2014 restoring will replace current configuration</div>'),i+="</div>"}if(a.config){var I=a.config.hasChanges?"\u{1F534}":"\u{1F7E2}";i+='<div style="margin-bottom: 12px; padding: 10px; background: var(--card-base); border-radius: 6px; border: 1px solid var(--border);"><div style="font-weight: 600; font-size: 0.85rem; margin-bottom: 4px;">'+I+" Configuration</div>",a.config.hasChanges?i+='<div style="font-size: 0.8rem; color: #f39c12;">Configuration differs \u2014 restoring will replace current settings</div>':i+='<div style="font-size: 0.8rem; color: var(--ok-fg);">No changes</div>',i+="</div>"}i+='<button id="compare-close-btn" style="padding: 8px 20px; background: var(--accent); border: none; color: white; border-radius: 6px; cursor: pointer; font-weight: 500;">Close</button></div></div>',document.body.insertAdjacentHTML("beforeend",i),document.getElementById("compare-close-btn")?.addEventListener("click",function(){document.getElementById("compare-overlay")?.remove()}),document.getElementById("compare-overlay")?.addEventListener("click",function(N){N.target===this&&this.remove()})}catch(N){showNotification("Compare error: "+N.message,"error")}}async function t(e,s){if(confirm("Restore "+s+" for "+e+`?
 
 This will replace current configuration, credentials, and data. Containers will be restarted.`))try{var n=await secureFetch("/api/v1/apps/"+encodeURIComponent(e)+"/revert/"+encodeURIComponent(s),{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify({restartContainers:!0})}),r=await n.json();r.success?(showNotification(e+" restored to "+s,"success"),setTimeout(function(){location.reload()},1500)):showNotification("Restore failed: "+(r.error||"Unknown"),"error")}catch(a){showNotification("Restore error: "+a.message,"error")}}})(),(function(){injectModal("stats-modal",`<div id="stats-modal" class="weather-modal">
     <div class="weather-modal-content" style="min-width: 750px; max-width: 950px;">
@@ -1305,7 +1305,7 @@ This will replace current configuration, credentials, and data. Containers will
         <button id="stats-cancel">Close</button>
       </div>
     </div>
-  </div>`);const x=document.getElementById("stats-modal"),E=document.getElementById("container-stats-btn"),R=document.getElementById("stats-cancel"),h=document.getElementById("stats-refresh-btn"),P=document.getElementById("stats-auto-refresh"),A=document.getElementById("stats-container"),D=document.getElementById("stats-aggregated-container"),j=document.getElementById("stats-alerts-container"),g=document.getElementById("stats-last-update");let $=null,k=null;function M(l){if(l===0||!l)return"0 B";const y=1024,u=["B","KB","MB","GB"],t=Math.floor(Math.log(l)/Math.log(y));return parseFloat((l/Math.pow(y,t)).toFixed(1))+" "+u[t]}function T(l){return l<30?"#2ecc71":l<70?"#f39c12":"#e74c3c"}function z(l){return l<50?"#2ecc71":l<80?"#f39c12":"#e74c3c"}async function C(){try{let l=null,y=!1;try{const e=await(await fetch("/api/v1/monitoring/stats")).json();e.success&&e.stats&&(l=e.stats,y=!0,k=e.stats)}catch{}if(!y){const e=await(await fetch("/api/v1/stats/containers")).json();if(e.success&&e.stats){l={};for(const s of e.stats)l[s.name]={name:s.name,current:{cpu:s.cpu,memory:{percent:s.memory.percent,usage:s.memory.used,limit:s.memory.limit,usageMB:Math.round(s.memory.used/1048576),limitMB:Math.round(s.memory.limit/1048576)},network:{rxBytes:s.network.rx,txBytes:s.network.tx,rxMB:(s.network.rx/1048576).toFixed(1),txMB:(s.network.tx/1048576).toFixed(1)},disk:{readMB:0,writeMB:0}},status:s.status};k=l}}if(!l||Object.keys(l).length===0){A.innerHTML='<div style="text-align: center; padding: 40px; color: var(--muted);">No running containers found</div>';return}let u='<div style="display: flex; flex-direction: column; gap: 8px;">';for(const[t,e]of Object.entries(l)){const s=e.current||e,n=s.cpu?.percent||0,r=s.memory?.percent||0,a=T(n),i=z(r),c=s.memory?.usage||s.memory?.used||0,I=s.memory?.limit||0,N=s.network?.rxBytes||s.network?.rx||0,U=s.network?.txBytes||s.network?.tx||0,_=e.aggregated;u+=`
+  </div>`);const x=document.getElementById("stats-modal"),E=document.getElementById("container-stats-btn"),j=document.getElementById("stats-cancel"),h=document.getElementById("stats-refresh-btn"),P=document.getElementById("stats-auto-refresh"),A=document.getElementById("stats-container"),D=document.getElementById("stats-aggregated-container"),R=document.getElementById("stats-alerts-container"),y=document.getElementById("stats-last-update");let $=null,k=null;function H(l){if(l===0||!l)return"0 B";const g=1024,p=["B","KB","MB","GB"],t=Math.floor(Math.log(l)/Math.log(g));return parseFloat((l/Math.pow(g,t)).toFixed(1))+" "+p[t]}function T(l){return l<30?"#2ecc71":l<70?"#f39c12":"#e74c3c"}function z(l){return l<50?"#2ecc71":l<80?"#f39c12":"#e74c3c"}async function C(){try{let l=null,g=!1;try{const e=await(await fetch("/api/v1/monitoring/stats")).json();e.success&&e.stats&&(l=e.stats,g=!0,k=e.stats)}catch{}if(!g){const e=await(await fetch("/api/v1/stats/containers")).json();if(e.success&&e.stats){l={};for(const s of e.stats)l[s.name]={name:s.name,current:{cpu:s.cpu,memory:{percent:s.memory.percent,usage:s.memory.used,limit:s.memory.limit,usageMB:Math.round(s.memory.used/1048576),limitMB:Math.round(s.memory.limit/1048576)},network:{rxBytes:s.network.rx,txBytes:s.network.tx,rxMB:(s.network.rx/1048576).toFixed(1),txMB:(s.network.tx/1048576).toFixed(1)},disk:{readMB:0,writeMB:0}},status:s.status};k=l}}if(!l||Object.keys(l).length===0){A.innerHTML='<div style="text-align: center; padding: 40px; color: var(--muted);">No running containers found</div>';return}let p='<div style="display: flex; flex-direction: column; gap: 8px;">';for(const[t,e]of Object.entries(l)){const s=e.current||e,n=s.cpu?.percent||0,r=s.memory?.percent||0,a=T(n),i=z(r),c=s.memory?.usage||s.memory?.used||0,I=s.memory?.limit||0,N=s.network?.rxBytes||s.network?.rx||0,U=s.network?.txBytes||s.network?.tx||0,_=e.aggregated;p+=`
           <div style="padding: 12px; background: var(--card-base); border-radius: 8px; border: 1px solid var(--border);">
             <div style="display: flex; align-items: center; gap: 12px; margin-bottom: 10px;">
               <span style="font-weight: 600; flex: 1;">${e.name||t}</span>
@@ -1330,19 +1330,19 @@ This will replace current configuration, credentials, and data. Containers will
                   </div>
                   <span style="font-size: 0.8rem; font-weight: 500; color: ${i}; min-width: 45px; text-align: right;">${r.toFixed(1)}%</span>
                 </div>
-                <div style="font-size: 0.65rem; color: var(--muted); margin-top: 2px;">${M(c)} / ${M(I)}</div>
+                <div style="font-size: 0.65rem; color: var(--muted); margin-top: 2px;">${H(c)} / ${H(I)}</div>
               </div>
               <div>
                 <div style="font-size: 0.7rem; color: var(--muted); margin-bottom: 4px;">Network</div>
                 <div style="font-size: 0.8rem;">
-                  <span style="color: #3498db;">\u2193 ${M(N)}</span>
+                  <span style="color: #3498db;">\u2193 ${H(N)}</span>
                   <span style="color: var(--muted); margin: 0 4px;">/</span>
-                  <span style="color: #e74c3c;">\u2191 ${M(U)}</span>
+                  <span style="color: #e74c3c;">\u2191 ${H(U)}</span>
                 </div>
               </div>
             </div>
-          </div>`}u+="</div>",A.innerHTML=u,g.textContent="Updated: "+new Date().toLocaleTimeString()}catch(l){A.innerHTML=`<div style="text-align: center; padding: 40px; color: var(--bad-fg);">\u274C Failed to load stats: ${escapeHtml(l.message)}</div>`}}async function H(){if(!D)return;const l=k;if(!l||Object.keys(l).length===0){D.innerHTML='<div class="panel-empty"><span class="empty-icon">\u{1F4C8}</span>No monitoring data available. Open the Live Stats tab first.</div>';return}let y='<div style="display: flex; flex-direction: column; gap: 12px;">';for(const[u,t]of Object.entries(l)){const e=t.aggregated;e&&(y+=`<div style="padding: 12px; background: var(--card-base); border-radius: 8px; border: 1px solid var(--border);">
-        <div style="font-weight: 600; margin-bottom: 10px;">${t.name||u}</div>
+          </div>`}p+="</div>",A.innerHTML=p,y.textContent="Updated: "+new Date().toLocaleTimeString()}catch(l){A.innerHTML=`<div style="text-align: center; padding: 40px; color: var(--bad-fg);">\u274C Failed to load stats: ${escapeHtml(l.message)}</div>`}}async function M(){if(!D)return;const l=k;if(!l||Object.keys(l).length===0){D.innerHTML='<div class="panel-empty"><span class="empty-icon">\u{1F4C8}</span>No monitoring data available. Open the Live Stats tab first.</div>';return}let g='<div style="display: flex; flex-direction: column; gap: 12px;">';for(const[p,t]of Object.entries(l)){const e=t.aggregated;e&&(g+=`<div style="padding: 12px; background: var(--card-base); border-radius: 8px; border: 1px solid var(--border);">
+        <div style="font-weight: 600; margin-bottom: 10px;">${t.name||p}</div>
         <div style="display: grid; grid-template-columns: repeat(4, 1fr); gap: 8px;">
           <div class="stat-mini-card"><span class="stat-val">${e.cpu?.avg?.toFixed(1)||0}%</span><span class="stat-lbl">Avg CPU</span></div>
           <div class="stat-mini-card"><span class="stat-val">${e.cpu?.max?.toFixed(1)||0}%</span><span class="stat-lbl">Max CPU</span></div>
@@ -1350,18 +1350,18 @@ This will replace current configuration, credentials, and data. Containers will
           <div class="stat-mini-card"><span class="stat-val">${e.memory?.max?.toFixed(1)||0}%</span><span class="stat-lbl">Max Mem</span></div>
         </div>
         ${e.dataPoints?`<div style="font-size: 0.7rem; color: var(--muted); margin-top: 6px;">${e.dataPoints} data points over ${e.timeRange||24}h</div>`:""}
-      </div>`)}y+="</div>",D.innerHTML=y}async function b(){if(!j)return;j.innerHTML='<div class="panel-empty"><span class="brand-spinner"></span> Loading alerts...</div>';const l=k;if(!l||Object.keys(l).length===0){j.innerHTML='<div class="panel-empty"><span class="empty-icon">\u{1F514}</span>No containers found. Open the Live Stats tab first.</div>';return}let y=!1;try{y=(await(await fetch("/api/v1/license/feature/resource-alerts")).json()).available}catch{y=!1}let u=[];try{const i=await(await fetch("/api/v1/monitoring/alerts?limit=50")).json();i.success&&(u=i.history||[])}catch{}let t={};try{const i=await(await fetch("/api/v1/monitoring/alerts/config")).json();i.success&&(t=i.configs||{})}catch{}const s=Object.entries(l).map(([a,i])=>{const c=t[a]||{cpuThreshold:80,memoryThreshold:90,diskIOThreshold:50,autoRestart:!1,enabled:!1};return`
+      </div>`)}g+="</div>",D.innerHTML=g}async function b(){if(!R)return;R.innerHTML='<div class="panel-empty"><span class="brand-spinner"></span> Loading alerts...</div>';const l=k;if(!l||Object.keys(l).length===0){R.innerHTML='<div class="panel-empty"><span class="empty-icon">\u{1F514}</span>No containers found. Open the Live Stats tab first.</div>';return}let g=!1;try{g=(await(await fetch("/api/v1/license/feature/resource-alerts")).json()).available}catch{g=!1}let p=[];try{const i=await(await fetch("/api/v1/monitoring/alerts?limit=50")).json();i.success&&(p=i.history||[])}catch{}let t={};try{const i=await(await fetch("/api/v1/monitoring/alerts/config")).json();i.success&&(t=i.configs||{})}catch{}const s=Object.entries(l).map(([a,i])=>{const c=t[a]||{cpuThreshold:80,memoryThreshold:90,diskIOThreshold:50,autoRestart:!1,enabled:!1};return`
         <tr data-container="${a}">
           <td style="font-weight: 600; padding: 8px;">${i.name||a}</td>
-          <td style="padding: 4px 8px;"><input type="number" class="alert-cpu" value="${c.cpuThreshold??80}" min="0" max="100" style="width: 60px; font-size: 0.8rem; padding: 2px 4px;" ${y?"":"disabled"} /></td>
-          <td style="padding: 4px 8px;"><input type="number" class="alert-mem" value="${c.memoryThreshold??90}" min="0" max="100" style="width: 60px; font-size: 0.8rem; padding: 2px 4px;" ${y?"":"disabled"} /></td>
-          <td style="padding: 4px 8px;"><input type="number" class="alert-disk" value="${c.diskIOThreshold??50}" min="0" max="1000" style="width: 70px; font-size: 0.8rem; padding: 2px 4px;" ${y?"":"disabled"} /></td>
-          <td style="padding: 4px 8px;"><input type="checkbox" class="alert-autorestart" ${c.autoRestart?"checked":""} ${y?"":"disabled"} /></td>
+          <td style="padding: 4px 8px;"><input type="number" class="alert-cpu" value="${c.cpuThreshold??80}" min="0" max="100" style="width: 60px; font-size: 0.8rem; padding: 2px 4px;" ${g?"":"disabled"} /></td>
+          <td style="padding: 4px 8px;"><input type="number" class="alert-mem" value="${c.memoryThreshold??90}" min="0" max="100" style="width: 60px; font-size: 0.8rem; padding: 2px 4px;" ${g?"":"disabled"} /></td>
+          <td style="padding: 4px 8px;"><input type="number" class="alert-disk" value="${c.diskIOThreshold??50}" min="0" max="1000" style="width: 70px; font-size: 0.8rem; padding: 2px 4px;" ${g?"":"disabled"} /></td>
+          <td style="padding: 4px 8px;"><input type="checkbox" class="alert-autorestart" ${c.autoRestart?"checked":""} ${g?"":"disabled"} /></td>
           <td style="padding: 4px 8px;">
             <button class="alert-test-btn btn-xs" data-container="${a}" data-name="${i.name||a}" style="padding: 2px 8px; font-size: 0.75rem; background: var(--card-base); border: 1px solid var(--border); border-radius: 4px; cursor: pointer;">Test</button>
           </td>
         </tr>
-      `}).join(""),n=u.map(a=>{const i=new Date(a.timestamp).toLocaleString(),c=a.notified?"\u2713":"\u2014";return`
+      `}).join(""),n=p.map(a=>{const i=new Date(a.timestamp).toLocaleString(),c=a.notified?"\u2713":"\u2014";return`
         <tr>
           <td style="padding: 6px 8px; font-size: 0.8rem; color: var(--muted);">${i}</td>
           <td style="padding: 6px 8px; font-weight: 500;">${a.containerName||a.containerId}</td>
@@ -1370,7 +1370,7 @@ This will replace current configuration, credentials, and data. Containers will
           <td style="padding: 6px 8px; text-align: center;">${c}</td>
           <td style="padding: 6px 8px; font-size: 0.75rem; color: ${a.autoRestartTriggered?"#f39c12":"var(--muted)"};">${a.autoRestartTriggered?"\u21BB":""}</td>
         </tr>
-      `}).join(""),r=y?`
+      `}).join(""),r=g?`
       <div style="margin-bottom: 20px;">
         <div style="display: flex; align-items: center; justify-content: space-between; margin-bottom: 10px;">
           <h4 style="margin: 0; font-size: 0.9rem;">\u2699\uFE0F Alert Configuration</h4>
@@ -1401,7 +1401,7 @@ This will replace current configuration, credentials, and data. Containers will
         <p style="margin: 6px 0 0; font-size: 0.75rem; color: var(--muted);">Upgrade to configure resource alert thresholds per container.</p>
         <button id="upgrade-for-alerts" style="margin-top: 8px; padding: 4px 12px; font-size: 0.75rem; background: #f1c40f; color: #000; border: none; border-radius: 4px; cursor: pointer; font-weight: 600;">Upgrade Now</button>
       </div>
-    `;j.innerHTML=`
+    `;R.innerHTML=`
       ${r}
       <div>
         <h4 style="margin: 0 0 10px; font-size: 0.9rem;">\u{1F4CB} Recent Alerts</h4>
@@ -1423,21 +1423,21 @@ This will replace current configuration, credentials, and data. Containers will
           </div>
         `:'<div style="color: var(--muted); text-align: center; padding: 20px;">No alerts recorded yet.</div>'}
       </div>
-    `,document.getElementById("save-all-alerts")?.addEventListener("click",async()=>{const a={};document.querySelectorAll("#stats-alerts-container tr[data-container]").forEach(i=>{const c=i.dataset.container;a[c]={cpuThreshold:parseInt(i.querySelector(".alert-cpu")?.value)||80,memoryThreshold:parseInt(i.querySelector(".alert-mem")?.value)||90,diskIOThreshold:parseInt(i.querySelector(".alert-disk")?.value)||50,autoRestart:!!i.querySelector(".alert-autorestart")?.checked,enabled:!0}});try{const c=await(await secureFetch("/api/v1/monitoring/alerts/config",{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify({configs:a})})).json(),I=document.getElementById("save-all-alerts");I.textContent=c.success?"\u2705 Saved":"\u274C Failed",setTimeout(()=>{I.textContent="Save All"},2e3)}catch{const c=document.getElementById("save-all-alerts");c.textContent="\u274C Error",setTimeout(()=>{c.textContent="Save All"},2e3)}}),document.getElementById("go-to-notifications")?.addEventListener("click",a=>{a.preventDefault(),x.classList.remove("show"),v(),document.getElementById("manage-notifications")?.click()}),document.querySelectorAll(".alert-test-btn").forEach(a=>{a.addEventListener("click",async()=>{const i=a.textContent;a.textContent="...";try{await secureFetch(`/api/v1/monitoring/alerts/${a.dataset.container}/test`,{method:"POST"}),a.textContent="\u2705",showNotification("Test alert sent for "+a.dataset.name,"success",3e3)}catch{a.textContent="\u274C"}setTimeout(()=>{a.textContent=i},2e3)})}),document.getElementById("upgrade-for-alerts")?.addEventListener("click",()=>{x.classList.remove("show"),v(),typeof openLicenseModal=="function"&&openLicenseModal()})}function d(){$&&clearInterval($),P?.checked&&($=setInterval(C,DC.POLL.STATS))}function v(){$&&(clearInterval($),$=null)}E?.addEventListener("click",()=>{x.classList.add("show"),C(),d()}),R?.addEventListener("click",()=>{x.classList.remove("show"),v()}),x?.addEventListener("click",l=>{l.target===x&&(x.classList.remove("show"),v())}),h?.addEventListener("click",C),P?.addEventListener("change",()=>{P.checked?d():v()}),document.querySelector('[data-panel="stats-aggregated"]')?.addEventListener("click",H),document.querySelector('[data-panel="stats-alerts"]')?.addEventListener("click",b);const S=document.getElementById("stats-history-container"),O=document.getElementById("stats-history-container-area"),m=document.querySelectorAll(".stats-range-btn");let f="1h";function B(l){switch(l){case"1h":return 3600*1e3;case"24h":return 1440*60*1e3;case"7d":return 10080*60*1e3;case"30d":return 720*60*60*1e3;case"1y":return 365*24*60*60*1e3;default:return 3600*1e3}}function w(l){return l==="raw"?"live (10s samples)":l==="hourly"?"hourly average":l==="daily"?"daily average":l}function L(l,y,u,t,e){if(!l||l.length===0)return`<div style="text-align: center; color: var(--muted); padding: 20px;">No data for ${escapeHtml(t)}</div>`;const s=l.map(y).filter(q=>q!=null);if(s.length===0)return`<div style="text-align: center; color: var(--muted); padding: 20px;">No data for ${escapeHtml(t)}</div>`;const n=Math.max(...s,1),r=Math.min(...s,0),a=n-r||1,i=600,c=80,I=4,N=(i-I*2)/Math.max(s.length-1,1),U=s.map((q,J)=>{const X=I+J*N,Q=c-I-(q-r)/a*(c-I*2);return`${X.toFixed(1)},${Q.toFixed(1)}`}).join(" "),_=s[s.length-1],F=s.reduce((q,J)=>q+J,0)/s.length;return`
+    `,document.getElementById("save-all-alerts")?.addEventListener("click",async()=>{const a={};document.querySelectorAll("#stats-alerts-container tr[data-container]").forEach(i=>{const c=i.dataset.container;a[c]={cpuThreshold:parseInt(i.querySelector(".alert-cpu")?.value)||80,memoryThreshold:parseInt(i.querySelector(".alert-mem")?.value)||90,diskIOThreshold:parseInt(i.querySelector(".alert-disk")?.value)||50,autoRestart:!!i.querySelector(".alert-autorestart")?.checked,enabled:!0}});try{const c=await(await secureFetch("/api/v1/monitoring/alerts/config",{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify({configs:a})})).json(),I=document.getElementById("save-all-alerts");I.textContent=c.success?"\u2705 Saved":"\u274C Failed",setTimeout(()=>{I.textContent="Save All"},2e3)}catch{const c=document.getElementById("save-all-alerts");c.textContent="\u274C Error",setTimeout(()=>{c.textContent="Save All"},2e3)}}),document.getElementById("go-to-notifications")?.addEventListener("click",a=>{a.preventDefault(),x.classList.remove("show"),v(),document.getElementById("manage-notifications")?.click()}),document.querySelectorAll(".alert-test-btn").forEach(a=>{a.addEventListener("click",async()=>{const i=a.textContent;a.textContent="...";try{await secureFetch(`/api/v1/monitoring/alerts/${a.dataset.container}/test`,{method:"POST"}),a.textContent="\u2705",showNotification("Test alert sent for "+a.dataset.name,"success",3e3)}catch{a.textContent="\u274C"}setTimeout(()=>{a.textContent=i},2e3)})}),document.getElementById("upgrade-for-alerts")?.addEventListener("click",()=>{x.classList.remove("show"),v(),typeof openLicenseModal=="function"&&openLicenseModal()})}function d(){$&&clearInterval($),P?.checked&&($=setInterval(C,DC.POLL.STATS))}function v(){$&&(clearInterval($),$=null)}E?.addEventListener("click",()=>{x.classList.add("show"),C(),d()}),j?.addEventListener("click",()=>{x.classList.remove("show"),v()}),x?.addEventListener("click",l=>{l.target===x&&(x.classList.remove("show"),v())}),h?.addEventListener("click",C),P?.addEventListener("change",()=>{P.checked?d():v()}),document.querySelector('[data-panel="stats-aggregated"]')?.addEventListener("click",M),document.querySelector('[data-panel="stats-alerts"]')?.addEventListener("click",b);const S=document.getElementById("stats-history-container"),O=document.getElementById("stats-history-container-area"),m=document.querySelectorAll(".stats-range-btn");let f="1h";function B(l){switch(l){case"1h":return 3600*1e3;case"24h":return 1440*60*1e3;case"7d":return 10080*60*1e3;case"30d":return 720*60*60*1e3;case"1y":return 365*24*60*60*1e3;default:return 3600*1e3}}function w(l){return l==="raw"?"live (10s samples)":l==="hourly"?"hourly average":l==="daily"?"daily average":l}function L(l,g,p,t,e){if(!l||l.length===0)return`<div style="text-align: center; color: var(--muted); padding: 20px;">No data for ${escapeHtml(t)}</div>`;const s=l.map(g).filter(q=>q!=null);if(s.length===0)return`<div style="text-align: center; color: var(--muted); padding: 20px;">No data for ${escapeHtml(t)}</div>`;const n=Math.max(...s,1),r=Math.min(...s,0),a=n-r||1,i=600,c=80,I=4,N=(i-I*2)/Math.max(s.length-1,1),U=s.map((q,J)=>{const X=I+J*N,Q=c-I-(q-r)/a*(c-I*2);return`${X.toFixed(1)},${Q.toFixed(1)}`}).join(" "),_=s[s.length-1],F=s.reduce((q,J)=>q+J,0)/s.length;return`
       <div style="margin-bottom: 14px;">
         <div style="display: flex; align-items: baseline; gap: 12px; margin-bottom: 4px;">
           <span style="font-weight: 600; font-size: 0.9rem;">${escapeHtml(t)}</span>
           <span style="font-size: 0.75rem; color: var(--muted);">last ${_.toFixed(1)}${e} \xB7 avg ${F.toFixed(1)}${e} \xB7 max ${n.toFixed(1)}${e}</span>
         </div>
         <svg viewBox="0 0 ${i} ${c}" preserveAspectRatio="none" style="width: 100%; height: ${c}px; background: var(--base); border-radius: 4px;">
-          <polyline fill="none" stroke="${u}" stroke-width="1.5" points="${U}" />
+          <polyline fill="none" stroke="${p}" stroke-width="1.5" points="${U}" />
         </svg>
       </div>
-    `}function o(){if(!S)return;const l=k||{},y=S.value,u=Object.entries(l);if(u.length===0){S.innerHTML='<option value="">No containers</option>';return}S.innerHTML=u.map(([t,e])=>`<option value="${escapeHtml(t)}">${escapeHtml(e.name||t)}</option>`).join(""),y&&l[y]&&(S.value=y)}async function p(){if(!O||!S)return;const l=S.value;if(!l){O.innerHTML='<div class="panel-empty"><span class="empty-icon">\u{1F4CA}</span>No container selected.</div>';return}const y=Date.now(),u=y-B(f);O.innerHTML='<div class="panel-empty"><span class="brand-spinner"></span> Loading history...</div>';try{const e=await(await fetch(`/api/v1/monitoring/history/${encodeURIComponent(l)}?startTime=${u}&endTime=${y}`)).json();if(!e.success)throw new Error(e.error||"Failed to load history");const s=e.samples||[],n=e.tier||"raw";if(s.length===0){O.innerHTML=`<div class="panel-empty"><span class="empty-icon">\u{1F4CA}</span>No data for the last ${f}. Tier: ${w(n)}.</div>`;return}const r=n==="raw",a=r?U=>U.cpu?.percent:U=>U.cpu?.avg,i=r?U=>U.memory?.percent:U=>U.memory?.avgPercent,c=r?U=>U.network?.rxMB||0:U=>U.network?.rxMB||0,I=r?U=>U.network?.txMB||0:U=>U.network?.txMB||0;let N=`
+    `}function o(){if(!S)return;const l=k||{},g=S.value,p=Object.entries(l);if(p.length===0){S.innerHTML='<option value="">No containers</option>';return}S.innerHTML=p.map(([t,e])=>`<option value="${escapeHtml(t)}">${escapeHtml(e.name||t)}</option>`).join(""),g&&l[g]&&(S.value=g)}async function u(){if(!O||!S)return;const l=S.value;if(!l){O.innerHTML='<div class="panel-empty"><span class="empty-icon">\u{1F4CA}</span>No container selected.</div>';return}const g=Date.now(),p=g-B(f);O.innerHTML='<div class="panel-empty"><span class="brand-spinner"></span> Loading history...</div>';try{const e=await(await fetch(`/api/v1/monitoring/history/${encodeURIComponent(l)}?startTime=${p}&endTime=${g}`)).json();if(!e.success)throw new Error(e.error||"Failed to load history");const s=e.samples||[],n=e.tier||"raw";if(s.length===0){O.innerHTML=`<div class="panel-empty"><span class="empty-icon">\u{1F4CA}</span>No data for the last ${f}. Tier: ${w(n)}.</div>`;return}const r=n==="raw",a=r?U=>U.cpu?.percent:U=>U.cpu?.avg,i=r?U=>U.memory?.percent:U=>U.memory?.avgPercent,c=r?U=>U.network?.rxMB||0:U=>U.network?.rxMB||0,I=r?U=>U.network?.txMB||0:U=>U.network?.txMB||0;let N=`
         <div style="font-size: 0.75rem; color: var(--muted); margin-bottom: 8px;">
-          ${s.length} samples \xB7 ${escapeHtml(w(n))} \xB7 ${new Date(u).toLocaleString()} \u2192 ${new Date(y).toLocaleString()}
+          ${s.length} samples \xB7 ${escapeHtml(w(n))} \xB7 ${new Date(p).toLocaleString()} \u2192 ${new Date(g).toLocaleString()}
         </div>
-      `;N+=L(s,a,"#2ecc71","CPU","%"),N+=L(s,i,"#3498db","Memory","%"),N+=L(s,c,"#9b59b6","Network RX"," MB"),N+=L(s,I,"#e67e22","Network TX"," MB"),O.innerHTML=N}catch(t){O.innerHTML=`<div class="panel-empty"><span class="empty-icon">\u26A0\uFE0F</span>Failed to load history: ${escapeHtml(t.message)}</div>`}}m.forEach(l=>{l.addEventListener("click",()=>{m.forEach(y=>y.classList.remove("active")),l.classList.add("active"),f=l.dataset.range,p()})}),S?.addEventListener("change",p),document.querySelector('[data-panel="stats-history"]')?.addEventListener("click",()=>{o(),p()})})(),(function(){injectModal("health-modal",`<div id="health-modal" class="weather-modal">
+      `;N+=L(s,a,"#2ecc71","CPU","%"),N+=L(s,i,"#3498db","Memory","%"),N+=L(s,c,"#9b59b6","Network RX"," MB"),N+=L(s,I,"#e67e22","Network TX"," MB"),O.innerHTML=N}catch(t){O.innerHTML=`<div class="panel-empty"><span class="empty-icon">\u26A0\uFE0F</span>Failed to load history: ${escapeHtml(t.message)}</div>`}}m.forEach(l=>{l.addEventListener("click",()=>{m.forEach(g=>g.classList.remove("active")),l.classList.add("active"),f=l.dataset.range,u()})}),S?.addEventListener("change",u),document.querySelector('[data-panel="stats-history"]')?.addEventListener("click",()=>{o(),u()})})(),(function(){injectModal("health-modal",`<div id="health-modal" class="weather-modal">
     <div class="weather-modal-content" style="min-width: 800px; max-width: 1000px;">
       <h3>\u{1F3E5} Health Check Dashboard</h3>
       <p class="modal-subtitle">
@@ -1561,7 +1561,7 @@ This will replace current configuration, credentials, and data. Containers will
         <button id="health-cancel">Close</button>
       </div>
     </div>
-  </div>`);const x=document.getElementById("health-modal"),E=document.getElementById("health-check-btn"),R=document.getElementById("health-cancel"),h=document.getElementById("health-refresh-btn"),P=document.getElementById("health-status-container"),A=document.getElementById("health-incidents-container"),D=document.getElementById("health-config-container"),j=document.getElementById("health-last-update"),g=document.getElementById("health-add-btn"),$=document.getElementById("health-config-form"),k=document.getElementById("health-form-title"),M=document.getElementById("health-form-cancel"),T=document.getElementById("health-form-save"),z="dashcaddy-health-settings",C={retentionDays:30,pollingInterval:60,statsPollingInterval:30,maxEntriesPerService:500,diskUsageThreshold:80},H=document.getElementById("health-global-save"),b=document.getElementById("health-global-reset"),d=document.getElementById("health-global-status"),v=document.getElementById("health-setting-retention"),S=document.getElementById("health-setting-interval"),O=document.getElementById("health-setting-stats-interval"),m=document.getElementById("health-setting-max-entries"),f=document.getElementById("health-setting-disk-threshold");function B(){try{const r=safeGet(z),a=r?JSON.parse(r):{};return Object.assign({},C,a)}catch{return Object.assign({},C)}}function w(){const r=B();v&&(v.value=r.retentionDays),S&&(S.value=r.pollingInterval),O&&(O.value=r.statsPollingInterval),m&&(m.value=r.maxEntriesPerService),f&&(f.value=r.diskUsageThreshold)}function L(){const r={retentionDays:Math.max(1,Math.min(3650,parseInt(v?.value)||C.retentionDays)),pollingInterval:Math.max(5,Math.min(3600,parseInt(S?.value)||C.pollingInterval)),statsPollingInterval:Math.max(5,Math.min(3600,parseInt(O?.value)||C.statsPollingInterval)),maxEntriesPerService:Math.max(10,Math.min(1e5,parseInt(m?.value)||C.maxEntriesPerService)),diskUsageThreshold:Math.max(50,Math.min(99,parseInt(f?.value)||C.diskUsageThreshold))};try{safeSet(z,JSON.stringify(r)),w(),d&&(d.textContent="Saved \u2713",d.style.color="var(--ok-fg)",setTimeout(()=>{d&&(d.textContent="")},2500)),typeof showNotification=="function"&&showNotification("Global health settings saved","success")}catch(a){d&&(d.textContent="Save failed",d.style.color="var(--bad-fg)"),typeof showNotification=="function"&&showNotification("Failed to save settings: "+a.message,"error")}}function o(){try{safeSet(z,JSON.stringify(C))}catch{}w(),d&&(d.textContent="Reset to defaults \u2713",d.style.color="var(--ok-fg)",setTimeout(()=>{d&&(d.textContent="")},2500))}w(),H?.addEventListener("click",L),b?.addEventListener("click",o);let p=null;function l(r){return r>=99.9?"var(--ok-fg)":r>=95?"#f39c12":"var(--bad-fg)"}function y(r){const a={critical:"var(--bad-fg)",high:"#ff6b6b",medium:"#f39c12",low:"var(--muted)"};return`<span style="padding: 2px 8px; border-radius: 4px; font-size: 0.75rem; background: ${a[r]||"var(--muted)"}20; color: ${a[r]||"var(--muted)"};">${r}</span>`}async function u(){try{const a=await(await fetch("/api/v1/health-checks/status")).json();if(!a.success||!a.status||Object.keys(a.status).length===0){P.innerHTML='<div class="panel-empty"><span class="empty-icon">\u{1F3E5}</span>No health checks configured. Go to the Configure tab to add services.</div>';return}const i=Object.values(a.status);let c='<table style="width: 100%; border-collapse: collapse; font-size: 0.85rem;">';c+='<tr style="border-bottom: 1px solid var(--border); color: var(--muted); text-align: left;">',c+='<th style="padding: 8px;">Service</th><th style="padding: 8px;">Status</th>',c+='<th style="padding: 8px;">Uptime 24h</th><th style="padding: 8px;">Uptime 7d</th>',c+='<th style="padding: 8px;">Avg Response</th><th style="padding: 8px;">Last Check</th></tr>';for(const I of i){const N=I.status==="up",U=N?"var(--dot-ok)":"var(--dot-bad)",_=I.uptime?.["24h"]??"-",F=I.uptime?.["7d"]??"-",q=I.avgResponseTime!=null?Math.round(I.avgResponseTime)+"ms":"-",J=I.timestamp?timeAgo(I.timestamp):"-";c+=`<tr style="border-bottom: 1px solid var(--border); cursor: pointer;" data-health-id="${escapeHtml(I.serviceId)}">`,c+=`<td style="padding: 8px; font-weight: 500;">${escapeHtml(I.name||I.serviceId)}</td>`,c+=`<td style="padding: 8px;"><span style="display: inline-block; width: 8px; height: 8px; border-radius: 50%; background: ${U}; margin-right: 6px;"></span>${N?"Up":"Down"}</td>`,c+=`<td style="padding: 8px; color: ${typeof _=="number"?l(_):"var(--muted)"};">${typeof _=="number"?_.toFixed(1)+"%":_}</td>`,c+=`<td style="padding: 8px; color: ${typeof F=="number"?l(F):"var(--muted)"};">${typeof F=="number"?F.toFixed(1)+"%":F}</td>`,c+=`<td style="padding: 8px;">${q}</td>`,c+=`<td style="padding: 8px; color: var(--muted);">${J}</td>`,c+="</tr>",c+=`<tr id="health-detail-${escapeHtml(I.serviceId)}" style="display: none;"><td colspan="6" style="padding: 12px; background: var(--bg); border-bottom: 1px solid var(--border);"><div class="panel-empty"><span class="brand-spinner"></span> Loading details...</div></td></tr>`}c+="</table>",P.innerHTML=c,j.textContent="Updated "+new Date().toLocaleTimeString(),P.querySelectorAll("tr[data-health-id]").forEach(I=>{I.addEventListener("click",async()=>{const N=I.dataset.healthId,U=document.getElementById("health-detail-"+N);if(U){if(U.style.display!=="none"){U.style.display="none";return}U.style.display="";try{const F=await(await fetch(`/api/v1/health-checks/${N}/stats?hours=24`)).json();if(F.success&&F.stats){const q=F.stats,J=q.responseTime||{};U.querySelector("td").innerHTML=`
+  </div>`);const x=document.getElementById("health-modal"),E=document.getElementById("health-check-btn"),j=document.getElementById("health-cancel"),h=document.getElementById("health-refresh-btn"),P=document.getElementById("health-status-container"),A=document.getElementById("health-incidents-container"),D=document.getElementById("health-config-container"),R=document.getElementById("health-last-update"),y=document.getElementById("health-add-btn"),$=document.getElementById("health-config-form"),k=document.getElementById("health-form-title"),H=document.getElementById("health-form-cancel"),T=document.getElementById("health-form-save"),z="dashcaddy-health-settings",C={retentionDays:30,pollingInterval:60,statsPollingInterval:30,maxEntriesPerService:500,diskUsageThreshold:80},M=document.getElementById("health-global-save"),b=document.getElementById("health-global-reset"),d=document.getElementById("health-global-status"),v=document.getElementById("health-setting-retention"),S=document.getElementById("health-setting-interval"),O=document.getElementById("health-setting-stats-interval"),m=document.getElementById("health-setting-max-entries"),f=document.getElementById("health-setting-disk-threshold");function B(){try{const r=safeGet(z),a=r?JSON.parse(r):{};return Object.assign({},C,a)}catch{return Object.assign({},C)}}function w(){const r=B();v&&(v.value=r.retentionDays),S&&(S.value=r.pollingInterval),O&&(O.value=r.statsPollingInterval),m&&(m.value=r.maxEntriesPerService),f&&(f.value=r.diskUsageThreshold)}function L(){const r={retentionDays:Math.max(1,Math.min(3650,parseInt(v?.value)||C.retentionDays)),pollingInterval:Math.max(5,Math.min(3600,parseInt(S?.value)||C.pollingInterval)),statsPollingInterval:Math.max(5,Math.min(3600,parseInt(O?.value)||C.statsPollingInterval)),maxEntriesPerService:Math.max(10,Math.min(1e5,parseInt(m?.value)||C.maxEntriesPerService)),diskUsageThreshold:Math.max(50,Math.min(99,parseInt(f?.value)||C.diskUsageThreshold))};try{safeSet(z,JSON.stringify(r)),w(),d&&(d.textContent="Saved \u2713",d.style.color="var(--ok-fg)",setTimeout(()=>{d&&(d.textContent="")},2500)),typeof showNotification=="function"&&showNotification("Global health settings saved","success")}catch(a){d&&(d.textContent="Save failed",d.style.color="var(--bad-fg)"),typeof showNotification=="function"&&showNotification("Failed to save settings: "+a.message,"error")}}function o(){try{safeSet(z,JSON.stringify(C))}catch{}w(),d&&(d.textContent="Reset to defaults \u2713",d.style.color="var(--ok-fg)",setTimeout(()=>{d&&(d.textContent="")},2500))}w(),M?.addEventListener("click",L),b?.addEventListener("click",o);let u=null;function l(r){return r>=99.9?"var(--ok-fg)":r>=95?"#f39c12":"var(--bad-fg)"}function g(r){const a={critical:"var(--bad-fg)",high:"#ff6b6b",medium:"#f39c12",low:"var(--muted)"};return`<span style="padding: 2px 8px; border-radius: 4px; font-size: 0.75rem; background: ${a[r]||"var(--muted)"}20; color: ${a[r]||"var(--muted)"};">${r}</span>`}async function p(){try{const a=await(await fetch("/api/v1/health-checks/status")).json();if(!a.success||!a.status||Object.keys(a.status).length===0){P.innerHTML='<div class="panel-empty"><span class="empty-icon">\u{1F3E5}</span>No health checks configured. Go to the Configure tab to add services.</div>';return}const i=Object.values(a.status);let c='<table style="width: 100%; border-collapse: collapse; font-size: 0.85rem;">';c+='<tr style="border-bottom: 1px solid var(--border); color: var(--muted); text-align: left;">',c+='<th style="padding: 8px;">Service</th><th style="padding: 8px;">Status</th>',c+='<th style="padding: 8px;">Uptime 24h</th><th style="padding: 8px;">Uptime 7d</th>',c+='<th style="padding: 8px;">Avg Response</th><th style="padding: 8px;">Last Check</th></tr>';for(const I of i){const N=I.status==="up",U=N?"var(--dot-ok)":"var(--dot-bad)",_=I.uptime?.["24h"]??"-",F=I.uptime?.["7d"]??"-",q=I.avgResponseTime!=null?Math.round(I.avgResponseTime)+"ms":"-",J=I.timestamp?timeAgo(I.timestamp):"-";c+=`<tr style="border-bottom: 1px solid var(--border); cursor: pointer;" data-health-id="${escapeHtml(I.serviceId)}">`,c+=`<td style="padding: 8px; font-weight: 500;">${escapeHtml(I.name||I.serviceId)}</td>`,c+=`<td style="padding: 8px;"><span style="display: inline-block; width: 8px; height: 8px; border-radius: 50%; background: ${U}; margin-right: 6px;"></span>${N?"Up":"Down"}</td>`,c+=`<td style="padding: 8px; color: ${typeof _=="number"?l(_):"var(--muted)"};">${typeof _=="number"?_.toFixed(1)+"%":_}</td>`,c+=`<td style="padding: 8px; color: ${typeof F=="number"?l(F):"var(--muted)"};">${typeof F=="number"?F.toFixed(1)+"%":F}</td>`,c+=`<td style="padding: 8px;">${q}</td>`,c+=`<td style="padding: 8px; color: var(--muted);">${J}</td>`,c+="</tr>",c+=`<tr id="health-detail-${escapeHtml(I.serviceId)}" style="display: none;"><td colspan="6" style="padding: 12px; background: var(--bg); border-bottom: 1px solid var(--border);"><div class="panel-empty"><span class="brand-spinner"></span> Loading details...</div></td></tr>`}c+="</table>",P.innerHTML=c,R.textContent="Updated "+new Date().toLocaleTimeString(),P.querySelectorAll("tr[data-health-id]").forEach(I=>{I.addEventListener("click",async()=>{const N=I.dataset.healthId,U=document.getElementById("health-detail-"+N);if(U){if(U.style.display!=="none"){U.style.display="none";return}U.style.display="";try{const F=await(await fetch(`/api/v1/health-checks/${N}/stats?hours=24`)).json();if(F.success&&F.stats){const q=F.stats,J=q.responseTime||{};U.querySelector("td").innerHTML=`
                 <div style="display: grid; grid-template-columns: repeat(4, 1fr); gap: 12px; font-size: 0.82rem;">
                   <div><span style="color: var(--muted);">Total Checks</span><br><strong>${q.totalChecks||0}</strong></div>
                   <div><span style="color: var(--muted);">Uptime</span><br><strong style="color: ${l(q.uptime||0)};">${(q.uptime||0).toFixed(2)}%</strong></div>
@@ -1574,11 +1574,11 @@ This will replace current configuration, credentials, and data. Containers will
                 </div>`}else U.querySelector("td").innerHTML='<div class="panel-empty">No detailed stats available for this period.</div>'}catch(_){U.querySelector("td").innerHTML=`<div class="panel-empty" style="color: var(--bad-fg);">Failed: ${escapeHtml(_.message)}</div>`}}})})}catch(r){P.innerHTML=`<div class="panel-empty" style="color: var(--bad-fg);">Failed to load health status: ${escapeHtml(r.message)}</div>`}}async function t(){try{const[r,a]=await Promise.all([fetch("/api/v1/health-checks/incidents"),fetch("/api/v1/health-checks/incidents/history?limit=50")]),i=await r.json(),c=await a.json();let I="";const N=i.success&&i.incidents?i.incidents:[];if(N.length>0){I+='<div style="margin-bottom: 16px;"><h4 style="color: var(--bad-fg); margin: 0 0 8px;">Open Incidents ('+N.length+")</h4>";for(const _ of N)I+=`<div style="padding: 10px 12px; margin-bottom: 8px; border: 1px solid var(--bad-fg)30; border-radius: 8px; background: var(--bad-bg);">
             <div style="display: flex; justify-content: space-between; align-items: center;">
               <span style="font-weight: 500;">${escapeHtml(_.serviceId)}</span>
-              <span>${y(_.severity)}</span>
+              <span>${g(_.severity)}</span>
             </div>
             <div style="font-size: 0.82rem; color: var(--muted); margin-top: 4px;">${escapeHtml(_.message)}</div>
             <div style="font-size: 0.75rem; color: var(--muted); margin-top: 4px;">Started ${timeAgo(_.createdAt)} \xB7 ${_.occurrences||1} occurrence(s)</div>
-          </div>`;I+="</div>"}else I+='<div style="padding: 12px; margin-bottom: 16px; border: 1px solid var(--ok-fg)30; border-radius: 8px; background: var(--ok-bg); text-align: center; color: var(--ok-fg); font-size: 0.9rem;">All services operational \u2014 no open incidents</div>';const U=c.success&&c.history?c.history:[];if(U.length>0){I+='<h4 style="margin: 0 0 8px; color: var(--muted);">Incident History</h4>',I+='<table style="width: 100%; border-collapse: collapse; font-size: 0.82rem;">',I+='<tr style="border-bottom: 1px solid var(--border); color: var(--muted);"><th style="padding: 6px; text-align: left;">Service</th><th style="padding: 6px; text-align: left;">Type</th><th style="padding: 6px; text-align: left;">Severity</th><th style="padding: 6px; text-align: left;">Status</th><th style="padding: 6px; text-align: left;">Duration</th><th style="padding: 6px; text-align: left;">When</th></tr>';for(const _ of U){const F=_.status==="resolved",q=F&&_.duration?_.duration<6e4?Math.round(_.duration/1e3)+"s":Math.round(_.duration/6e4)+"m":"-";I+='<tr style="border-bottom: 1px solid var(--border);">',I+=`<td style="padding: 6px;">${escapeHtml(_.serviceId)}</td>`,I+=`<td style="padding: 6px;">${escapeHtml(_.type)}</td>`,I+=`<td style="padding: 6px;">${y(_.severity)}</td>`,I+=`<td style="padding: 6px;"><span style="color: ${F?"var(--ok-fg)":"var(--bad-fg)"};">${_.status}</span></td>`,I+=`<td style="padding: 6px;">${q}</td>`,I+=`<td style="padding: 6px; color: var(--muted);">${timeAgo(_.createdAt)}</td>`,I+="</tr>"}I+="</table>"}A.innerHTML=I||'<div class="panel-empty"><span class="empty-icon">\u{1F6A8}</span>No incidents recorded yet.</div>'}catch(r){A.innerHTML=`<div class="panel-empty" style="color: var(--bad-fg);">Failed: ${escapeHtml(r.message)}</div>`}}async function e(){try{const a=await(await fetch("/api/v1/health-checks/status")).json(),i=a.success&&a.status?Object.values(a.status):[];if(i.length===0){D.innerHTML='<div class="panel-empty"><span class="empty-icon">\u2699\uFE0F</span>No health checks configured yet. Click "Add Health Check" below.</div>';return}let c='<table style="width: 100%; border-collapse: collapse; font-size: 0.85rem;">';c+='<tr style="border-bottom: 1px solid var(--border); color: var(--muted);"><th style="padding: 8px; text-align: left;">Service</th><th style="padding: 8px; text-align: left;">Status</th><th style="padding: 8px; text-align: left;">SLA Target</th><th style="padding: 8px; text-align: right;">Actions</th></tr>';for(const I of i){const N=I.status==="up";c+='<tr style="border-bottom: 1px solid var(--border);">',c+=`<td style="padding: 8px; font-weight: 500;">${escapeHtml(I.name||I.serviceId)}</td>`,c+=`<td style="padding: 8px; color: ${N?"var(--ok-fg)":"var(--bad-fg)"};">${N?"Up":"Down"}</td>`,c+=`<td style="padding: 8px;">${I.sla?.target?I.sla.target+"%":"-"}</td>`,c+='<td style="padding: 8px; text-align: right;">',c+=`<button onclick="document.dispatchEvent(new CustomEvent('health-edit', {detail:'${escapeHtml(I.serviceId)}'}))" style="padding: 4px 10px; font-size: 0.78rem; margin-right: 4px;">Edit</button>`,c+=`<button onclick="document.dispatchEvent(new CustomEvent('health-delete', {detail:'${escapeHtml(I.serviceId)}'}))" style="padding: 4px 10px; font-size: 0.78rem; color: var(--bad-fg); border-color: var(--bad-fg);">Delete</button>`,c+="</td></tr>"}c+="</table>",D.innerHTML=c}catch(r){D.innerHTML=`<div class="panel-empty" style="color: var(--bad-fg);">Failed: ${escapeHtml(r.message)}</div>`}}function s(r,a,i,c,I,N,U){p=r||null,k.textContent=r?"Edit Health Check":"Add Health Check",document.getElementById("health-form-id").value=r||"",document.getElementById("health-form-id").disabled=!!r,document.getElementById("health-form-name").value=a||"",document.getElementById("health-form-url").value=i||"",document.getElementById("health-form-timeout").value=c||1e4,document.getElementById("health-form-codes").value=I||"200",document.getElementById("health-form-sla").value=N||99.9,document.getElementById("health-form-slow").value=U||5e3,$.style.display="",g.style.display="none"}function n(){$.style.display="none",g.style.display="",p=null}g?.addEventListener("click",()=>s("","","",1e4,"200",99.9,5e3)),M?.addEventListener("click",n),T?.addEventListener("click",async()=>{const r=p||document.getElementById("health-form-id").value.trim();if(!r)return showNotification("Service ID is required","warning");const a=document.getElementById("health-form-url").value.trim();if(!a)return showNotification("URL is required","warning");const i=document.getElementById("health-form-codes").value.split(",").map(I=>parseInt(I.trim())).filter(Boolean),c={name:document.getElementById("health-form-name").value.trim()||r,url:a,timeout:parseInt(document.getElementById("health-form-timeout").value)||1e4,expectedStatusCodes:i.length?i:[200],sla:{target:parseFloat(document.getElementById("health-form-sla").value)||99.9},slowResponseThreshold:parseInt(document.getElementById("health-form-slow").value)||5e3};try{T.textContent="Saving...",T.disabled=!0;const N=await(await secureFetch(`/api/v1/health-checks/${encodeURIComponent(r)}/configure`,{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify(c)})).json();if(!N.success)throw new Error(N.error||"Save failed");n(),e(),u()}catch(I){showNotification("Error: "+I.message,"error")}finally{T.textContent="Save",T.disabled=!1}}),document.addEventListener("health-edit",async r=>{const a=r.detail;s(a,"","",1e4,"200",99.9,5e3)}),document.addEventListener("health-delete",async r=>{const a=r.detail;if(confirm(`Delete health check for "${a}"?`))try{const c=await(await secureFetch(`/api/v1/health-checks/${encodeURIComponent(a)}/configure`,{method:"DELETE"})).json();if(!c.success)throw new Error(c.error);e(),u()}catch(i){showNotification("Error: "+i.message,"error")}}),E?.addEventListener("click",()=>{x?.classList.add("show"),u()}),wireModal(x,R),h?.addEventListener("click",u),document.querySelector('[data-panel="health-incidents"]')?.addEventListener("click",t),document.querySelector('[data-panel="health-config"]')?.addEventListener("click",e)})(),(function(){injectModal("updates-modal",`<div id="updates-modal" class="weather-modal">
+          </div>`;I+="</div>"}else I+='<div style="padding: 12px; margin-bottom: 16px; border: 1px solid var(--ok-fg)30; border-radius: 8px; background: var(--ok-bg); text-align: center; color: var(--ok-fg); font-size: 0.9rem;">All services operational \u2014 no open incidents</div>';const U=c.success&&c.history?c.history:[];if(U.length>0){I+='<h4 style="margin: 0 0 8px; color: var(--muted);">Incident History</h4>',I+='<table style="width: 100%; border-collapse: collapse; font-size: 0.82rem;">',I+='<tr style="border-bottom: 1px solid var(--border); color: var(--muted);"><th style="padding: 6px; text-align: left;">Service</th><th style="padding: 6px; text-align: left;">Type</th><th style="padding: 6px; text-align: left;">Severity</th><th style="padding: 6px; text-align: left;">Status</th><th style="padding: 6px; text-align: left;">Duration</th><th style="padding: 6px; text-align: left;">When</th></tr>';for(const _ of U){const F=_.status==="resolved",q=F&&_.duration?_.duration<6e4?Math.round(_.duration/1e3)+"s":Math.round(_.duration/6e4)+"m":"-";I+='<tr style="border-bottom: 1px solid var(--border);">',I+=`<td style="padding: 6px;">${escapeHtml(_.serviceId)}</td>`,I+=`<td style="padding: 6px;">${escapeHtml(_.type)}</td>`,I+=`<td style="padding: 6px;">${g(_.severity)}</td>`,I+=`<td style="padding: 6px;"><span style="color: ${F?"var(--ok-fg)":"var(--bad-fg)"};">${_.status}</span></td>`,I+=`<td style="padding: 6px;">${q}</td>`,I+=`<td style="padding: 6px; color: var(--muted);">${timeAgo(_.createdAt)}</td>`,I+="</tr>"}I+="</table>"}A.innerHTML=I||'<div class="panel-empty"><span class="empty-icon">\u{1F6A8}</span>No incidents recorded yet.</div>'}catch(r){A.innerHTML=`<div class="panel-empty" style="color: var(--bad-fg);">Failed: ${escapeHtml(r.message)}</div>`}}async function e(){try{const a=await(await fetch("/api/v1/health-checks/status")).json(),i=a.success&&a.status?Object.values(a.status):[];if(i.length===0){D.innerHTML='<div class="panel-empty"><span class="empty-icon">\u2699\uFE0F</span>No health checks configured yet. Click "Add Health Check" below.</div>';return}let c='<table style="width: 100%; border-collapse: collapse; font-size: 0.85rem;">';c+='<tr style="border-bottom: 1px solid var(--border); color: var(--muted);"><th style="padding: 8px; text-align: left;">Service</th><th style="padding: 8px; text-align: left;">Status</th><th style="padding: 8px; text-align: left;">SLA Target</th><th style="padding: 8px; text-align: right;">Actions</th></tr>';for(const I of i){const N=I.status==="up";c+='<tr style="border-bottom: 1px solid var(--border);">',c+=`<td style="padding: 8px; font-weight: 500;">${escapeHtml(I.name||I.serviceId)}</td>`,c+=`<td style="padding: 8px; color: ${N?"var(--ok-fg)":"var(--bad-fg)"};">${N?"Up":"Down"}</td>`,c+=`<td style="padding: 8px;">${I.sla?.target?I.sla.target+"%":"-"}</td>`,c+='<td style="padding: 8px; text-align: right;">',c+=`<button onclick="document.dispatchEvent(new CustomEvent('health-edit', {detail:'${escapeHtml(I.serviceId)}'}))" style="padding: 4px 10px; font-size: 0.78rem; margin-right: 4px;">Edit</button>`,c+=`<button onclick="document.dispatchEvent(new CustomEvent('health-delete', {detail:'${escapeHtml(I.serviceId)}'}))" style="padding: 4px 10px; font-size: 0.78rem; color: var(--bad-fg); border-color: var(--bad-fg);">Delete</button>`,c+="</td></tr>"}c+="</table>",D.innerHTML=c}catch(r){D.innerHTML=`<div class="panel-empty" style="color: var(--bad-fg);">Failed: ${escapeHtml(r.message)}</div>`}}function s(r,a,i,c,I,N,U){u=r||null,k.textContent=r?"Edit Health Check":"Add Health Check",document.getElementById("health-form-id").value=r||"",document.getElementById("health-form-id").disabled=!!r,document.getElementById("health-form-name").value=a||"",document.getElementById("health-form-url").value=i||"",document.getElementById("health-form-timeout").value=c||1e4,document.getElementById("health-form-codes").value=I||"200",document.getElementById("health-form-sla").value=N||99.9,document.getElementById("health-form-slow").value=U||5e3,$.style.display="",y.style.display="none"}function n(){$.style.display="none",y.style.display="",u=null}y?.addEventListener("click",()=>s("","","",1e4,"200",99.9,5e3)),H?.addEventListener("click",n),T?.addEventListener("click",async()=>{const r=u||document.getElementById("health-form-id").value.trim();if(!r)return showNotification("Service ID is required","warning");const a=document.getElementById("health-form-url").value.trim();if(!a)return showNotification("URL is required","warning");const i=document.getElementById("health-form-codes").value.split(",").map(I=>parseInt(I.trim())).filter(Boolean),c={name:document.getElementById("health-form-name").value.trim()||r,url:a,timeout:parseInt(document.getElementById("health-form-timeout").value)||1e4,expectedStatusCodes:i.length?i:[200],sla:{target:parseFloat(document.getElementById("health-form-sla").value)||99.9},slowResponseThreshold:parseInt(document.getElementById("health-form-slow").value)||5e3};try{T.textContent="Saving...",T.disabled=!0;const N=await(await secureFetch(`/api/v1/health-checks/${encodeURIComponent(r)}/configure`,{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify(c)})).json();if(!N.success)throw new Error(N.error||"Save failed");n(),e(),p()}catch(I){showNotification("Error: "+I.message,"error")}finally{T.textContent="Save",T.disabled=!1}}),document.addEventListener("health-edit",async r=>{const a=r.detail;s(a,"","",1e4,"200",99.9,5e3)}),document.addEventListener("health-delete",async r=>{const a=r.detail;if(confirm(`Delete health check for "${a}"?`))try{const c=await(await secureFetch(`/api/v1/health-checks/${encodeURIComponent(a)}/configure`,{method:"DELETE"})).json();if(!c.success)throw new Error(c.error);e(),p()}catch(i){showNotification("Error: "+i.message,"error")}}),E?.addEventListener("click",()=>{x?.classList.add("show"),p()}),wireModal(x,j),h?.addEventListener("click",p),document.querySelector('[data-panel="health-incidents"]')?.addEventListener("click",t),document.querySelector('[data-panel="health-config"]')?.addEventListener("click",e)})(),(function(){injectModal("updates-modal",`<div id="updates-modal" class="weather-modal">
     <div class="weather-modal-content" style="min-width: 750px; max-width: 950px;">
       <h3>\u2B06\uFE0F Update Management</h3>
       <p class="modal-subtitle">
@@ -1652,17 +1652,17 @@ This will replace current configuration, credentials, and data. Containers will
         <button id="updates-cancel">Close</button>
       </div>
     </div>
-  </div>`);const x=document.getElementById("updates-modal"),E=document.getElementById("updates-btn"),R=document.getElementById("updates-cancel"),h=document.getElementById("updates-check-btn"),P=document.getElementById("updates-available-container"),A=document.getElementById("updates-history-container"),D=document.getElementById("updates-auto-container"),j=document.getElementById("updates-last-check");async function g(){try{const t=await(await fetch("/api/v1/updates/available")).json();if(!t.success)throw new Error(t.error);const e=t.updates||[];if(e.length===0){P.innerHTML='<div class="panel-empty"><span class="empty-icon">\u2705</span>All containers are up to date.</div>',j.textContent="",document.getElementById("updates-update-all-btn").style.display="none",document.getElementById("updates-count-badge").style.display="none",window._pendingUpdates=[];return}let s='<table style="width: 100%; border-collapse: collapse; font-size: 0.85rem;">';s+='<tr style="border-bottom: 1px solid var(--border); color: var(--muted);"><th style="padding: 8px; text-align: left;">Container</th><th style="padding: 8px; text-align: left;">Image</th><th style="padding: 8px; text-align: left;">Current</th><th style="padding: 8px; text-align: left;">Latest</th><th style="padding: 8px; text-align: right;">Actions</th></tr>';for(const a of e){const i=(()=>{const c=window.APPS||[];for(const I of c)if(I.containerId===a.containerId||I.name===a.containerName||I.id===a.containerName)return I.id;return a.containerName})();s+=`<tr data-app-id="${escapeHtml(i)}" style="border-bottom: 1px solid var(--border);">`,s+=`<td style="padding: 8px; font-weight: 500;">${escapeHtml(a.containerName)}</td>`,s+=`<td style="padding: 8px; color: var(--muted);">${escapeHtml(a.imageName)}</td>`,s+=`<td style="padding: 8px;"><code style="font-size: 0.78rem; background: var(--bg); padding: 2px 6px; border-radius: 4px;">${escapeHtml(a.currentDigest)}</code></td>`,s+=`<td style="padding: 8px;"><code style="font-size: 0.78rem; background: var(--ok-bg); color: var(--ok-fg); padding: 2px 6px; border-radius: 4px;">${escapeHtml(a.latestDigest)}</code></td>`,s+='<td style="padding: 8px; text-align: right;">',s+=`<button class="update-now-btn" data-id="${escapeHtml(a.containerId)}" data-name="${escapeHtml(a.containerName)}" style="padding: 4px 10px; font-size: 0.78rem; background: var(--accent); color: var(--bg); border-color: var(--accent); margin-right: 4px;">Update</button>`,s+=`<button class="rollback-btn" data-id="${escapeHtml(a.containerId)}" data-name="${escapeHtml(a.containerName)}" style="padding: 4px 10px; font-size: 0.78rem;">Rollback</button>`,s+="</td></tr>"}s+="</table>",P.innerHTML=s,j.textContent=e.length+" update(s) available";const n=document.getElementById("updates-count-badge"),r=document.getElementById("updates-update-all-btn");n&&(n.textContent=e.length+" pending",n.style.display=""),r&&e.length>0&&(r.style.display=""),window._pendingUpdates=e,P.querySelectorAll(".update-now-btn").forEach(a=>{a.addEventListener("click",async()=>{const i=a.dataset.id,c=a.dataset.name;if(confirm(`Update "${c}" to the latest version? The container will restart.`)){a.textContent="Updating...",a.disabled=!0;try{const N=await(await secureFetch(`/api/v1/updates/update/${encodeURIComponent(i)}`,{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify({autoRollback:!0})})).json();if(N.success)a.textContent="Done!",a.style.background="var(--ok-fg)",setTimeout(()=>g(),2e3);else throw new Error(N.error||"Update failed")}catch(I){a.textContent="Failed",a.style.color="var(--bad-fg)",showNotification("Update error: "+I.message,"error"),setTimeout(()=>{a.textContent="Update",a.disabled=!1,a.style.color="",a.style.background=""},3e3)}}})}),P.querySelectorAll(".rollback-btn").forEach(a=>{a.addEventListener("click",async()=>{const i=a.dataset.id,c=a.dataset.name;if(confirm(`Rollback "${c}" to its previous version?`)){a.textContent="Rolling back...",a.disabled=!0;try{const N=await(await secureFetch(`/api/v1/updates/rollback/${encodeURIComponent(i)}`,{method:"POST"})).json();if(N.success)a.textContent="Rolled back!",setTimeout(()=>g(),2e3);else throw new Error(N.error||"Rollback failed")}catch(I){a.textContent="Failed",showNotification("Rollback error: "+I.message,"error"),setTimeout(()=>{a.textContent="Rollback",a.disabled=!1},3e3)}}})})}catch(u){P.innerHTML=`<div class="panel-empty" style="color: var(--bad-fg);">Failed: ${escapeHtml(u.message)}</div>`}}async function $(){const u=window._pendingUpdates||[];if(!u.length)return;const t=document.getElementById("updates-update-all-btn");if(!confirm(`Update all ${u.length} containers? Each will restart.`))return;t.textContent="\u23F3 Updating...",t.disabled=!0;let e=0,s=0;for(const n of u)try{(await(await secureFetch(`/api/v1/updates/update/${encodeURIComponent(n.containerId)}`,{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify({autoRollback:!0})})).json()).success?e++:s++}catch{s++}t.textContent="\u2705 Done",showNotification(`Update all: ${e} succeeded, ${s} failed.`,e>0&&s===0?"success":"error"),setTimeout(()=>{t.textContent="\u2B06\uFE0F Update All",t.disabled=!1,g()},3e3)}document.getElementById("updates-update-all-btn")?.addEventListener("click",$);async function k(){h.textContent="\u{1F50D} Checking...",h.disabled=!0;try{const t=await(await secureFetch("/api/v1/updates/check",{method:"POST"})).json();if(!t.success)throw new Error(t.error);h.textContent="\u2705 Done!",await g()}catch(u){h.textContent="\u274C Failed",showNotification("Check error: "+u.message,"error")}setTimeout(()=>{h.textContent="\u{1F50D} Check for Updates",h.disabled=!1},3e3)}async function M(){try{A.innerHTML='<div class="panel-empty"><span class="brand-spinner"></span> Loading...</div>';const t=await(await fetch("/api/v1/updates/history?limit=50")).json(),e=t.success&&t.history?t.history:[];if(e.length===0){A.innerHTML='<div class="panel-empty"><span class="empty-icon">\u{1F4CB}</span>No update history yet.</div>';return}let s='<table style="width: 100%; border-collapse: collapse; font-size: 0.82rem;">';s+='<tr style="border-bottom: 1px solid var(--border); color: var(--muted);"><th style="padding: 6px; text-align: left;">When</th><th style="padding: 6px; text-align: left;">Container</th><th style="padding: 6px; text-align: left;">Image</th><th style="padding: 6px; text-align: left;">Duration</th><th style="padding: 6px; text-align: left;">Status</th></tr>';for(const n of e){const r=n.status==="success",a=n.duration?n.duration<1e3?n.duration+"ms":Math.round(n.duration/1e3)+"s":"-";s+='<tr style="border-bottom: 1px solid var(--border);">',s+=`<td style="padding: 6px; color: var(--muted);">${timeAgo(n.timestamp)}</td>`,s+=`<td style="padding: 6px; font-weight: 500;">${escapeHtml(n.containerName)}</td>`,s+=`<td style="padding: 6px; color: var(--muted);">${escapeHtml(n.imageName)}</td>`,s+=`<td style="padding: 6px;">${a}</td>`,s+=`<td style="padding: 6px;"><span style="color: ${r?"var(--ok-fg)":"var(--bad-fg)"};">${r?"\u2713 success":"\u2717 failed"}</span></td>`,s+="</tr>",!r&&n.error&&(s+=`<tr><td colspan="5" style="padding: 4px 6px 8px; font-size: 0.78rem; color: var(--bad-fg);">${escapeHtml(n.error)}</td></tr>`)}s+="</table>",A.innerHTML=s}catch(u){A.innerHTML=`<div class="panel-empty" style="color: var(--bad-fg);">Failed: ${escapeHtml(u.message)}</div>`}}async function T(){try{D.innerHTML='<div class="panel-empty"><span class="brand-spinner"></span> Loading...</div>';const[u,t]=await Promise.all([fetch("/api/v1/stats/containers"),fetch("/api/v1/updates/auto-update")]),e=await u.json(),s=await t.json(),n=e.success&&e.stats?e.stats:[],r=s.success&&s.config?s.config:{};if(n.length===0){D.innerHTML='<div class="panel-empty"><span class="empty-icon">\u{1F916}</span>No running containers found.</div>';return}let a='<div style="margin-bottom: 12px; font-size: 0.8rem; color: var(--muted);">Auto-updates run during maintenance window (default 2AM-4AM). Daily = every day, Weekly = Sundays, Monthly = 1st of month.</div>';a+='<table style="width: 100%; border-collapse: collapse; font-size: 0.85rem;">',a+='<tr style="border-bottom: 1px solid var(--border); color: var(--muted);"><th style="padding: 8px; text-align: left;">Container</th><th style="padding: 8px; text-align: left;">Schedule</th><th style="padding: 8px; text-align: left;">Window</th><th style="padding: 8px; text-align: left;">Rollback</th><th style="padding: 8px; text-align: left;">Last Run</th><th style="padding: 8px; text-align: right;">Actions</th></tr>';for(const i of n){const c=i.name||i.Names?.[0]?.replace(/^\//,"")||i.Id?.substring(0,12),I=i.containerId||i.Id,N=r[I]||{},U=N.enabled?N.schedule||"weekly":"",_=N.autoRollback!==!1,F=N.maintenanceWindow||"",q=N.lastAutoUpdate?timeAgo(N.lastAutoUpdate):"Never";a+=`<tr style="border-bottom: 1px solid var(--border);" data-container-id="${escapeHtml(I)}">`,a+=`<td style="padding: 8px; font-weight: 500;">${escapeHtml(c)}</td>`,a+=`<td style="padding: 8px;">
+  </div>`);const x=document.getElementById("updates-modal"),E=document.getElementById("updates-btn"),j=document.getElementById("updates-cancel"),h=document.getElementById("updates-check-btn"),P=document.getElementById("updates-available-container"),A=document.getElementById("updates-history-container"),D=document.getElementById("updates-auto-container"),R=document.getElementById("updates-last-check");async function y(){try{const t=await(await fetch("/api/v1/updates/available")).json();if(!t.success)throw new Error(t.error);const e=t.updates||[];if(e.length===0){P.innerHTML='<div class="panel-empty"><span class="empty-icon">\u2705</span>All containers are up to date.</div>',R.textContent="",document.getElementById("updates-update-all-btn").style.display="none",document.getElementById("updates-count-badge").style.display="none",window._pendingUpdates=[];return}let s='<table style="width: 100%; border-collapse: collapse; font-size: 0.85rem;">';s+='<tr style="border-bottom: 1px solid var(--border); color: var(--muted);"><th style="padding: 8px; text-align: left;">Container</th><th style="padding: 8px; text-align: left;">Image</th><th style="padding: 8px; text-align: left;">Current</th><th style="padding: 8px; text-align: left;">Latest</th><th style="padding: 8px; text-align: right;">Actions</th></tr>';for(const a of e){const i=(()=>{const c=window.APPS||[];for(const I of c)if(I.containerId===a.containerId||I.name===a.containerName||I.id===a.containerName)return I.id;return a.containerName})();s+=`<tr data-app-id="${escapeHtml(i)}" style="border-bottom: 1px solid var(--border);">`,s+=`<td style="padding: 8px; font-weight: 500;">${escapeHtml(a.containerName)}</td>`,s+=`<td style="padding: 8px; color: var(--muted);">${escapeHtml(a.imageName)}</td>`,s+=`<td style="padding: 8px;"><code style="font-size: 0.78rem; background: var(--bg); padding: 2px 6px; border-radius: 4px;">${escapeHtml(a.currentDigest)}</code></td>`,s+=`<td style="padding: 8px;"><code style="font-size: 0.78rem; background: var(--ok-bg); color: var(--ok-fg); padding: 2px 6px; border-radius: 4px;">${escapeHtml(a.latestDigest)}</code></td>`,s+='<td style="padding: 8px; text-align: right;">',s+=`<button class="update-now-btn" data-id="${escapeHtml(a.containerId)}" data-name="${escapeHtml(a.containerName)}" style="padding: 4px 10px; font-size: 0.78rem; background: var(--accent); color: var(--bg); border-color: var(--accent); margin-right: 4px;">Update</button>`,s+=`<button class="rollback-btn" data-id="${escapeHtml(a.containerId)}" data-name="${escapeHtml(a.containerName)}" style="padding: 4px 10px; font-size: 0.78rem;">Rollback</button>`,s+="</td></tr>"}s+="</table>",P.innerHTML=s,R.textContent=e.length+" update(s) available";const n=document.getElementById("updates-count-badge"),r=document.getElementById("updates-update-all-btn");n&&(n.textContent=e.length+" pending",n.style.display=""),r&&e.length>0&&(r.style.display=""),window._pendingUpdates=e,P.querySelectorAll(".update-now-btn").forEach(a=>{a.addEventListener("click",async()=>{const i=a.dataset.id,c=a.dataset.name;if(confirm(`Update "${c}" to the latest version? The container will restart.`)){a.textContent="Updating...",a.disabled=!0;try{const N=await(await secureFetch(`/api/v1/updates/update/${encodeURIComponent(i)}`,{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify({autoRollback:!0})})).json();if(N.success)a.textContent="Done!",a.style.background="var(--ok-fg)",setTimeout(()=>y(),2e3);else throw new Error(N.error||"Update failed")}catch(I){a.textContent="Failed",a.style.color="var(--bad-fg)",showNotification("Update error: "+I.message,"error"),setTimeout(()=>{a.textContent="Update",a.disabled=!1,a.style.color="",a.style.background=""},3e3)}}})}),P.querySelectorAll(".rollback-btn").forEach(a=>{a.addEventListener("click",async()=>{const i=a.dataset.id,c=a.dataset.name;if(confirm(`Rollback "${c}" to its previous version?`)){a.textContent="Rolling back...",a.disabled=!0;try{const N=await(await secureFetch(`/api/v1/updates/rollback/${encodeURIComponent(i)}`,{method:"POST"})).json();if(N.success)a.textContent="Rolled back!",setTimeout(()=>y(),2e3);else throw new Error(N.error||"Rollback failed")}catch(I){a.textContent="Failed",showNotification("Rollback error: "+I.message,"error"),setTimeout(()=>{a.textContent="Rollback",a.disabled=!1},3e3)}}})})}catch(p){P.innerHTML=`<div class="panel-empty" style="color: var(--bad-fg);">Failed: ${escapeHtml(p.message)}</div>`}}async function $(){const p=window._pendingUpdates||[];if(!p.length)return;const t=document.getElementById("updates-update-all-btn");if(!confirm(`Update all ${p.length} containers? Each will restart.`))return;t.textContent="\u23F3 Updating...",t.disabled=!0;let e=0,s=0;for(const n of p)try{(await(await secureFetch(`/api/v1/updates/update/${encodeURIComponent(n.containerId)}`,{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify({autoRollback:!0})})).json()).success?e++:s++}catch{s++}t.textContent="\u2705 Done",showNotification(`Update all: ${e} succeeded, ${s} failed.`,e>0&&s===0?"success":"error"),setTimeout(()=>{t.textContent="\u2B06\uFE0F Update All",t.disabled=!1,y()},3e3)}document.getElementById("updates-update-all-btn")?.addEventListener("click",$);async function k(){h.textContent="\u{1F50D} Checking...",h.disabled=!0;try{const t=await(await secureFetch("/api/v1/updates/check",{method:"POST"})).json();if(!t.success)throw new Error(t.error);h.textContent="\u2705 Done!",await y()}catch(p){h.textContent="\u274C Failed",showNotification("Check error: "+p.message,"error")}setTimeout(()=>{h.textContent="\u{1F50D} Check for Updates",h.disabled=!1},3e3)}async function H(){try{A.innerHTML='<div class="panel-empty"><span class="brand-spinner"></span> Loading...</div>';const t=await(await fetch("/api/v1/updates/history?limit=50")).json(),e=t.success&&t.history?t.history:[];if(e.length===0){A.innerHTML='<div class="panel-empty"><span class="empty-icon">\u{1F4CB}</span>No update history yet.</div>';return}let s='<table style="width: 100%; border-collapse: collapse; font-size: 0.82rem;">';s+='<tr style="border-bottom: 1px solid var(--border); color: var(--muted);"><th style="padding: 6px; text-align: left;">When</th><th style="padding: 6px; text-align: left;">Container</th><th style="padding: 6px; text-align: left;">Image</th><th style="padding: 6px; text-align: left;">Duration</th><th style="padding: 6px; text-align: left;">Status</th></tr>';for(const n of e){const r=n.status==="success",a=n.duration?n.duration<1e3?n.duration+"ms":Math.round(n.duration/1e3)+"s":"-";s+='<tr style="border-bottom: 1px solid var(--border);">',s+=`<td style="padding: 6px; color: var(--muted);">${timeAgo(n.timestamp)}</td>`,s+=`<td style="padding: 6px; font-weight: 500;">${escapeHtml(n.containerName)}</td>`,s+=`<td style="padding: 6px; color: var(--muted);">${escapeHtml(n.imageName)}</td>`,s+=`<td style="padding: 6px;">${a}</td>`,s+=`<td style="padding: 6px;"><span style="color: ${r?"var(--ok-fg)":"var(--bad-fg)"};">${r?"\u2713 success":"\u2717 failed"}</span></td>`,s+="</tr>",!r&&n.error&&(s+=`<tr><td colspan="5" style="padding: 4px 6px 8px; font-size: 0.78rem; color: var(--bad-fg);">${escapeHtml(n.error)}</td></tr>`)}s+="</table>",A.innerHTML=s}catch(p){A.innerHTML=`<div class="panel-empty" style="color: var(--bad-fg);">Failed: ${escapeHtml(p.message)}</div>`}}async function T(){try{D.innerHTML='<div class="panel-empty"><span class="brand-spinner"></span> Loading...</div>';const[p,t]=await Promise.all([fetch("/api/v1/stats/containers"),fetch("/api/v1/updates/auto-update")]),e=await p.json(),s=await t.json(),n=e.success&&e.stats?e.stats:[],r=s.success&&s.config?s.config:{};if(n.length===0){D.innerHTML='<div class="panel-empty"><span class="empty-icon">\u{1F916}</span>No running containers found.</div>';return}let a='<div style="margin-bottom: 12px; font-size: 0.8rem; color: var(--muted);">Auto-updates run during maintenance window (default 2AM-4AM). Daily = every day, Weekly = Sundays, Monthly = 1st of month.</div>';a+='<table style="width: 100%; border-collapse: collapse; font-size: 0.85rem;">',a+='<tr style="border-bottom: 1px solid var(--border); color: var(--muted);"><th style="padding: 8px; text-align: left;">Container</th><th style="padding: 8px; text-align: left;">Schedule</th><th style="padding: 8px; text-align: left;">Window</th><th style="padding: 8px; text-align: left;">Rollback</th><th style="padding: 8px; text-align: left;">Last Run</th><th style="padding: 8px; text-align: right;">Actions</th></tr>';for(const i of n){const c=i.name||i.Names?.[0]?.replace(/^\//,"")||i.Id?.substring(0,12),I=i.containerId||i.Id,N=r[I]||{},U=N.enabled?N.schedule||"weekly":"",_=N.autoRollback!==!1,F=N.maintenanceWindow||"",q=N.lastAutoUpdate?timeAgo(N.lastAutoUpdate):"Never";a+=`<tr style="border-bottom: 1px solid var(--border);" data-container-id="${escapeHtml(I)}">`,a+=`<td style="padding: 8px; font-weight: 500;">${escapeHtml(c)}</td>`,a+=`<td style="padding: 8px;">
           <select class="auto-schedule" data-id="${escapeHtml(I)}" style="padding: 4px 8px; border-radius: 4px; border: 1px solid var(--border); background: var(--bg); color: var(--fg); font-size: 0.82rem;">
             <option value=""${U?"":" selected"}>Disabled</option>
             <option value="daily"${U==="daily"?" selected":""}>Daily</option>
             <option value="weekly"${U==="weekly"?" selected":""}>Weekly</option>
             <option value="monthly"${U==="monthly"?" selected":""}>Monthly</option>
-          </select></td>`,a+=`<td style="padding: 8px;"><input type="text" class="auto-window" data-id="${escapeHtml(I)}" value="${escapeHtml(F)}" placeholder="02:00-04:00" style="width: 90px; padding: 3px 6px; font-size: 0.78rem; border: 1px solid var(--border); border-radius: 4px; background: var(--bg); color: var(--fg);" /></td>`,a+=`<td style="padding: 8px;"><input type="checkbox" class="auto-rollback" data-id="${escapeHtml(I)}"${_?" checked":""} /></td>`,a+=`<td style="padding: 8px; font-size: 0.78rem; color: var(--muted);">${q}</td>`,a+=`<td style="padding: 8px; text-align: right;"><button class="save-auto-btn" data-id="${escapeHtml(I)}" data-name="${escapeHtml(c)}" style="padding: 4px 10px; font-size: 0.78rem;">Save</button></td>`,a+="</tr>"}a+="</table>",D.innerHTML=a,D.querySelectorAll(".save-auto-btn").forEach(i=>{i.addEventListener("click",async()=>{const c=i.dataset.id,I=i.closest("tr"),N=I.querySelector(".auto-schedule").value,U=I.querySelector(".auto-rollback").checked,_=I.querySelector(".auto-window").value.trim();i.textContent="Saving...",i.disabled=!0;try{const q=await(await secureFetch(`/api/v1/updates/auto-update/${encodeURIComponent(c)}`,{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify({enabled:!!N,schedule:N||"weekly",autoRollback:U,maintenanceWindow:_||void 0})})).json();if(q.success)i.textContent="\u2713 Saved";else throw new Error(q.error)}catch(F){i.textContent="\u2717 Error",showNotification("Save error: "+F.message,"error")}setTimeout(()=>{i.textContent="Save",i.disabled=!1},2e3)})})}catch(u){D.innerHTML=`<div class="panel-empty" style="color: var(--bad-fg);">Failed: ${escapeHtml(u.message)}</div>`}}const z=document.getElementById("dashcaddy-current-version"),C=document.getElementById("dashcaddy-update-badge"),H=document.getElementById("dashcaddy-update-details"),b=document.getElementById("dashcaddy-new-version"),d=document.getElementById("dashcaddy-changelog"),v=document.getElementById("dashcaddy-apply-btn"),S=document.getElementById("dashcaddy-check-btn"),O=document.getElementById("dashcaddy-rollback-btn"),m=document.getElementById("dashcaddy-status-bar"),f=document.getElementById("dashcaddy-history-container");let B=null;function w(u,t){m&&(m.style.display="block",m.style.background=t==="error"?"var(--bad-bg)":t==="success"?"var(--ok-bg)":"var(--bg)",m.style.color=t==="error"?"var(--bad-fg)":t==="success"?"var(--ok-fg)":"var(--fg)",m.textContent=u)}async function L(){try{const t=await(await fetch("/api/v1/system/version")).json();if(t.success){const e=t.commit&&t.commit!=="unknown"?t.commit:null;z.textContent="v"+t.version+(e?" ("+e.substring(0,7)+")":"")}}catch{z.textContent="Unable to fetch version"}}async function o(u){u||(S.textContent="Checking...",S.disabled=!0);try{const e=await(await fetch("/api/v1/system/update-check")).json();if(B=e,e.success&&e.available&&e.remote){C.style.display="",H.style.display="",b.textContent="v"+e.remote.version,d.textContent=e.remote.changelog||"No changelog available.";const s=document.getElementById("updates-btn");if(s&&!s.querySelector(".update-dot")){const r=document.createElement("span");r.className="update-dot",r.style.cssText="position:absolute;top:2px;right:2px;width:8px;height:8px;border-radius:50%;background:var(--accent);",s.style.position="relative",s.appendChild(r)}const n=document.getElementById("updates-dashcaddy-tab");if(n&&!n.querySelector(".update-dot")){const r=document.createElement("span");r.className="update-dot",r.style.cssText="display:inline-block;width:6px;height:6px;border-radius:50%;background:var(--accent);margin-left:4px;vertical-align:middle;",n.appendChild(r)}}else C.style.display="none",H.style.display="none",await L(),u||w("You are running the latest version.","success");u||(S.textContent="Check for Updates",S.disabled=!1)}catch(t){u||(w("Failed to check: "+t.message,"error"),S.textContent="Check for Updates",S.disabled=!1)}}async function p(){if(!confirm("Apply DashCaddy update? The API container will restart."))return!1;v.textContent="Updating...",v.disabled=!0,w("Downloading and applying update...","info");try{const t=await(await secureFetch("/api/v1/system/update-apply",{method:"POST"})).json();if(t.success)return w("Update initiated: v"+(t.fromVersion||"?")+" \u2192 v"+(t.toVersion||"?")+". The container will restart shortly.","success"),v.textContent="Applied!",document.querySelectorAll(".update-dot").forEach(e=>e.remove()),!0;throw new Error(t.error||"Update failed")}catch(u){throw w("Update failed: "+u.message,"error"),v.textContent="Update Now",v.disabled=!1,u}}async function l(){try{const t=await(await fetch("/api/v1/system/update-history")).json(),e=t.success&&t.history?t.history:[];if(e.length===0){f.innerHTML='<div class="panel-empty"><span class="empty-icon">\u{1F4E6}</span>No self-update history.</div>';return}let s='<table style="width: 100%; border-collapse: collapse; font-size: 0.82rem;">';s+='<tr style="border-bottom: 1px solid var(--border); color: var(--muted);"><th style="padding: 6px; text-align: left;">When</th><th style="padding: 6px; text-align: left;">Version</th><th style="padding: 6px; text-align: left;">From</th><th style="padding: 6px; text-align: left;">Status</th></tr>';for(const n of e){const r=n.status==="success"?"\u2713 success":n.status==="pending"?"\u23F3 pending":n.status==="partial"?"\u26A0 partial":"\u2717 "+n.status,a=n.status==="success"?"var(--ok-fg)":n.status==="pending"?"var(--muted)":"var(--bad-fg)";s+='<tr style="border-bottom: 1px solid var(--border);">',s+='<td style="padding: 6px; color: var(--muted);">'+timeAgo(n.timestamp)+"</td>",s+='<td style="padding: 6px; font-weight: 500;">v'+escapeHtml(n.version)+(n.rollback?" (rollback)":"")+"</td>",s+='<td style="padding: 6px; color: var(--muted);">v'+escapeHtml(n.fromVersion||"?")+"</td>",s+='<td style="padding: 6px;"><span style="color: '+a+';">'+r+"</span></td>",s+="</tr>",n.error&&(s+='<tr><td colspan="4" style="padding: 4px 6px 8px; font-size: 0.78rem; color: var(--bad-fg);">'+escapeHtml(n.error)+"</td></tr>"),n.note&&(s+='<tr><td colspan="4" style="padding: 4px 6px 8px; font-size: 0.78rem; color: var(--muted);">'+escapeHtml(n.note)+"</td></tr>")}s+="</table>",f.innerHTML=s}catch(u){f.innerHTML='<div class="panel-empty" style="color: var(--bad-fg);">Failed: '+escapeHtml(u.message)+"</div>"}}async function y(){try{const t=await(await fetch("/api/v1/system/rollback-versions")).json(),e=t.success&&t.versions?t.versions:[];if(e.length===0){showNotification("No rollback versions available.","info");return}const s=prompt(`Available rollback versions:
+          </select></td>`,a+=`<td style="padding: 8px;"><input type="text" class="auto-window" data-id="${escapeHtml(I)}" value="${escapeHtml(F)}" placeholder="02:00-04:00" style="width: 90px; padding: 3px 6px; font-size: 0.78rem; border: 1px solid var(--border); border-radius: 4px; background: var(--bg); color: var(--fg);" /></td>`,a+=`<td style="padding: 8px;"><input type="checkbox" class="auto-rollback" data-id="${escapeHtml(I)}"${_?" checked":""} /></td>`,a+=`<td style="padding: 8px; font-size: 0.78rem; color: var(--muted);">${q}</td>`,a+=`<td style="padding: 8px; text-align: right;"><button class="save-auto-btn" data-id="${escapeHtml(I)}" data-name="${escapeHtml(c)}" style="padding: 4px 10px; font-size: 0.78rem;">Save</button></td>`,a+="</tr>"}a+="</table>",D.innerHTML=a,D.querySelectorAll(".save-auto-btn").forEach(i=>{i.addEventListener("click",async()=>{const c=i.dataset.id,I=i.closest("tr"),N=I.querySelector(".auto-schedule").value,U=I.querySelector(".auto-rollback").checked,_=I.querySelector(".auto-window").value.trim();i.textContent="Saving...",i.disabled=!0;try{const q=await(await secureFetch(`/api/v1/updates/auto-update/${encodeURIComponent(c)}`,{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify({enabled:!!N,schedule:N||"weekly",autoRollback:U,maintenanceWindow:_||void 0})})).json();if(q.success)i.textContent="\u2713 Saved";else throw new Error(q.error)}catch(F){i.textContent="\u2717 Error",showNotification("Save error: "+F.message,"error")}setTimeout(()=>{i.textContent="Save",i.disabled=!1},2e3)})})}catch(p){D.innerHTML=`<div class="panel-empty" style="color: var(--bad-fg);">Failed: ${escapeHtml(p.message)}</div>`}}const z=document.getElementById("dashcaddy-current-version"),C=document.getElementById("dashcaddy-update-badge"),M=document.getElementById("dashcaddy-update-details"),b=document.getElementById("dashcaddy-new-version"),d=document.getElementById("dashcaddy-changelog"),v=document.getElementById("dashcaddy-apply-btn"),S=document.getElementById("dashcaddy-check-btn"),O=document.getElementById("dashcaddy-rollback-btn"),m=document.getElementById("dashcaddy-status-bar"),f=document.getElementById("dashcaddy-history-container");let B=null;function w(p,t){m&&(m.style.display="block",m.style.background=t==="error"?"var(--bad-bg)":t==="success"?"var(--ok-bg)":"var(--bg)",m.style.color=t==="error"?"var(--bad-fg)":t==="success"?"var(--ok-fg)":"var(--fg)",m.textContent=p)}async function L(){try{const t=await(await fetch("/api/v1/system/version")).json();if(t.success){const e=t.commit&&t.commit!=="unknown"?t.commit:null;z.textContent="v"+t.version+(e?" ("+e.substring(0,7)+")":"")}}catch{z.textContent="Unable to fetch version"}}async function o(p){p||(S.textContent="Checking...",S.disabled=!0);try{const e=await(await fetch("/api/v1/system/update-check")).json();if(B=e,e.success&&e.available&&e.remote){C.style.display="",M.style.display="",b.textContent="v"+e.remote.version,d.textContent=e.remote.changelog||"No changelog available.";const s=document.getElementById("updates-btn");if(s&&!s.querySelector(".update-dot")){const r=document.createElement("span");r.className="update-dot",r.style.cssText="position:absolute;top:2px;right:2px;width:8px;height:8px;border-radius:50%;background:var(--accent);",s.style.position="relative",s.appendChild(r)}const n=document.getElementById("updates-dashcaddy-tab");if(n&&!n.querySelector(".update-dot")){const r=document.createElement("span");r.className="update-dot",r.style.cssText="display:inline-block;width:6px;height:6px;border-radius:50%;background:var(--accent);margin-left:4px;vertical-align:middle;",n.appendChild(r)}}else C.style.display="none",M.style.display="none",await L(),p||w("You are running the latest version.","success");p||(S.textContent="Check for Updates",S.disabled=!1)}catch(t){p||(w("Failed to check: "+t.message,"error"),S.textContent="Check for Updates",S.disabled=!1)}}async function u(){if(!confirm("Apply DashCaddy update? The API container will restart."))return!1;v.textContent="Updating...",v.disabled=!0,w("Downloading and applying update...","info");try{const t=await(await secureFetch("/api/v1/system/update-apply",{method:"POST"})).json();if(t.success)return w("Update initiated: v"+(t.fromVersion||"?")+" \u2192 v"+(t.toVersion||"?")+". The container will restart shortly.","success"),v.textContent="Applied!",document.querySelectorAll(".update-dot").forEach(e=>e.remove()),!0;throw new Error(t.error||"Update failed")}catch(p){throw w("Update failed: "+p.message,"error"),v.textContent="Update Now",v.disabled=!1,p}}async function l(){try{const t=await(await fetch("/api/v1/system/update-history")).json(),e=t.success&&t.history?t.history:[];if(e.length===0){f.innerHTML='<div class="panel-empty"><span class="empty-icon">\u{1F4E6}</span>No self-update history.</div>';return}let s='<table style="width: 100%; border-collapse: collapse; font-size: 0.82rem;">';s+='<tr style="border-bottom: 1px solid var(--border); color: var(--muted);"><th style="padding: 6px; text-align: left;">When</th><th style="padding: 6px; text-align: left;">Version</th><th style="padding: 6px; text-align: left;">From</th><th style="padding: 6px; text-align: left;">Status</th></tr>';for(const n of e){const r=n.status==="success"?"\u2713 success":n.status==="pending"?"\u23F3 pending":n.status==="partial"?"\u26A0 partial":"\u2717 "+n.status,a=n.status==="success"?"var(--ok-fg)":n.status==="pending"?"var(--muted)":"var(--bad-fg)";s+='<tr style="border-bottom: 1px solid var(--border);">',s+='<td style="padding: 6px; color: var(--muted);">'+timeAgo(n.timestamp)+"</td>",s+='<td style="padding: 6px; font-weight: 500;">v'+escapeHtml(n.version)+(n.rollback?" (rollback)":"")+"</td>",s+='<td style="padding: 6px; color: var(--muted);">v'+escapeHtml(n.fromVersion||"?")+"</td>",s+='<td style="padding: 6px;"><span style="color: '+a+';">'+r+"</span></td>",s+="</tr>",n.error&&(s+='<tr><td colspan="4" style="padding: 4px 6px 8px; font-size: 0.78rem; color: var(--bad-fg);">'+escapeHtml(n.error)+"</td></tr>"),n.note&&(s+='<tr><td colspan="4" style="padding: 4px 6px 8px; font-size: 0.78rem; color: var(--muted);">'+escapeHtml(n.note)+"</td></tr>")}s+="</table>",f.innerHTML=s}catch(p){f.innerHTML='<div class="panel-empty" style="color: var(--bad-fg);">Failed: '+escapeHtml(p.message)+"</div>"}}async function g(){try{const t=await(await fetch("/api/v1/system/rollback-versions")).json(),e=t.success&&t.versions?t.versions:[];if(e.length===0){showNotification("No rollback versions available.","info");return}const s=prompt(`Available rollback versions:
 `+e.join(`
 `)+`
 
-Enter version to rollback to:`);if(!s)return;if(!e.includes(s)){showNotification("Invalid version: "+s,"error");return}if(!confirm("Rollback DashCaddy to v"+s+"? The container will restart."))return;w("Rolling back to v"+s+"...","info");const r=await(await secureFetch("/api/v1/system/rollback",{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify({version:s})})).json();if(r.success)w("Rollback to v"+s+" initiated. Container will restart.","success");else throw new Error(r.error||"Rollback failed")}catch(u){w("Rollback failed: "+u.message,"error")}}S?.addEventListener("click",()=>o(!1)),v?.addEventListener("click",()=>p().catch(()=>{})),O?.addEventListener("click",y),h?.addEventListener("click",k),E?.addEventListener("click",()=>{x?.classList.add("show"),g()}),wireModal(x,R),window.openUpdateModal=function(u){x?.classList.add("show"),g().then(()=>{if(!u)return;const t=P.querySelector(`[data-app-id="${u}"]`);t&&(t.scrollIntoView({behavior:"smooth",block:"center"}),t.style.background="rgba(249,115,22,0.15)",setTimeout(()=>{t.style.background=""},3e3))})},document.querySelector('[data-panel="updates-history"]')?.addEventListener("click",M),document.querySelector('[data-panel="updates-auto"]')?.addEventListener("click",T),document.querySelector('[data-panel="updates-dashcaddy"]')?.addEventListener("click",()=>{L(),l(),B||o(!0)}),window.dcApplyUpdate=p,window.dcCheckForUpdate=o,setTimeout(()=>o(!0),5e3)})(),(function(){injectModal("docker-resources-modal",`<div id="docker-resources-modal" class="weather-modal">
+Enter version to rollback to:`);if(!s)return;if(!e.includes(s)){showNotification("Invalid version: "+s,"error");return}if(!confirm("Rollback DashCaddy to v"+s+"? The container will restart."))return;w("Rolling back to v"+s+"...","info");const r=await(await secureFetch("/api/v1/system/rollback",{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify({version:s})})).json();if(r.success)w("Rollback to v"+s+" initiated. Container will restart.","success");else throw new Error(r.error||"Rollback failed")}catch(p){w("Rollback failed: "+p.message,"error")}}S?.addEventListener("click",()=>o(!1)),v?.addEventListener("click",()=>u().catch(()=>{})),O?.addEventListener("click",g),h?.addEventListener("click",k),E?.addEventListener("click",()=>{x?.classList.add("show"),y()}),wireModal(x,j),window.openUpdateModal=function(p){x?.classList.add("show"),y().then(()=>{if(!p)return;const t=P.querySelector(`[data-app-id="${p}"]`);t&&(t.scrollIntoView({behavior:"smooth",block:"center"}),t.style.background="rgba(249,115,22,0.15)",setTimeout(()=>{t.style.background=""},3e3))})},document.querySelector('[data-panel="updates-history"]')?.addEventListener("click",H),document.querySelector('[data-panel="updates-auto"]')?.addEventListener("click",T),document.querySelector('[data-panel="updates-dashcaddy"]')?.addEventListener("click",()=>{L(),l(),B||o(!0)}),window.dcApplyUpdate=u,window.dcCheckForUpdate=o,setTimeout(()=>o(!0),5e3)})(),(function(){injectModal("docker-resources-modal",`<div id="docker-resources-modal" class="weather-modal">
     <div class="weather-modal-content" style="min-width: 750px; max-width: 950px;">
       <h3>\u{1F433} Docker Resources</h3>
       <p class="modal-subtitle">Manage volumes, networks, and view disk usage.</p>
@@ -1711,7 +1711,7 @@ Enter version to rollback to:`);if(!s)return;if(!e.includes(s)){showNotification
         <button id="dr-close">Close</button>
       </div>
     </div>
-  </div>`);const x=document.getElementById("docker-resources-modal"),E=document.getElementById("docker-resources-btn"),R=document.getElementById("dr-close");function h(j){if(!j||j===0)return"0 B";const g=["B","KB","MB","GB","TB"],$=Math.floor(Math.log(Math.abs(j))/Math.log(1024));return(j/Math.pow(1024,$)).toFixed(1)+" "+g[$]}async function P(){const j=document.getElementById("dr-vol-list");try{const $=(await getJSON("/api/v1/docker/volumes")).volumes||[];if($.length===0){j.innerHTML='<div class="panel-empty"><span class="empty-icon">\u{1F4E6}</span>No volumes found.</div>';return}let k='<table style="width: 100%; border-collapse: collapse; font-size: 0.82rem;">';k+='<tr style="border-bottom: 1px solid var(--border); color: var(--muted);"><th style="padding: 6px; text-align: left;">Name</th><th style="padding: 6px;">Driver</th><th style="padding: 6px;">Scope</th><th style="padding: 6px; text-align: right;">Actions</th></tr>';for(const M of $){const T=M.name==="buildkit"||M.name.length===64;k+='<tr style="border-bottom: 1px solid var(--border);">',k+=`<td style="padding: 6px; font-weight: 500; max-width: 300px; overflow: hidden; text-overflow: ellipsis; white-space: nowrap;" title="${escapeHtml(M.name)}">${escapeHtml(M.name.length>40?M.name.substring(0,37)+"...":M.name)}</td>`,k+=`<td style="padding: 6px; text-align: center; color: var(--muted);">${escapeHtml(M.driver)}</td>`,k+=`<td style="padding: 6px; text-align: center; color: var(--muted);">${escapeHtml(M.scope)}</td>`,k+='<td style="padding: 6px; text-align: right;">',T||(k+=`<button class="dr-vol-del" data-name="${escapeHtml(M.name)}" style="padding: 3px 8px; font-size: 0.75rem; color: var(--bad-fg);">Delete</button>`),k+="</td></tr>"}k+="</table>",j.innerHTML=k,j.querySelectorAll(".dr-vol-del").forEach(M=>{M.addEventListener("click",async()=>{if(confirm(`Delete volume "${M.dataset.name}"? Data will be lost.`)){M.textContent="...",M.disabled=!0;try{await deleteAPI(`/api/v1/docker/volumes/${encodeURIComponent(M.dataset.name)}?force=true`),P()}catch(T){showNotification("Delete failed: "+T.message,"error"),M.textContent="Delete",M.disabled=!1}}})})}catch(g){j.innerHTML=`<div class="panel-empty" style="color: var(--bad-fg);">Failed: ${escapeHtml(g.message)}</div>`}}document.getElementById("dr-vol-create")?.addEventListener("click",async()=>{const j=document.getElementById("dr-vol-name"),g=j.value.trim();if(!g){showNotification("Enter a volume name","warning");return}try{await postJSON("/api/v1/docker/volumes",{name:g}),j.value="",showNotification(`Volume "${g}" created`,"success"),P()}catch($){showNotification("Create failed: "+$.message,"error")}});async function A(){const j=document.getElementById("dr-net-list");try{const $=(await getJSON("/api/v1/docker/networks")).networks||[];if($.length===0){j.innerHTML='<div class="panel-empty"><span class="empty-icon">\u{1F310}</span>No networks found.</div>';return}let k='<table style="width: 100%; border-collapse: collapse; font-size: 0.82rem;">';k+='<tr style="border-bottom: 1px solid var(--border); color: var(--muted);"><th style="padding: 6px; text-align: left;">Name</th><th style="padding: 6px;">Driver</th><th style="padding: 6px;">Scope</th><th style="padding: 6px;">Containers</th><th style="padding: 6px; text-align: right;">Actions</th></tr>';for(const M of $){const T=["bridge","host","none"].includes(M.name);k+='<tr style="border-bottom: 1px solid var(--border);">',k+=`<td style="padding: 6px; font-weight: 500;">${escapeHtml(M.name)}</td>`,k+=`<td style="padding: 6px; text-align: center; color: var(--muted);">${escapeHtml(M.driver)}</td>`,k+=`<td style="padding: 6px; text-align: center; color: var(--muted);">${escapeHtml(M.scope)}</td>`,k+=`<td style="padding: 6px; text-align: center;">${M.containers}</td>`,k+='<td style="padding: 6px; text-align: right;">',T||(k+=`<button class="dr-net-del" data-id="${escapeHtml(M.id)}" data-name="${escapeHtml(M.name)}" style="padding: 3px 8px; font-size: 0.75rem; color: var(--bad-fg);">Delete</button>`),k+="</td></tr>"}k+="</table>",j.innerHTML=k,j.querySelectorAll(".dr-net-del").forEach(M=>{M.addEventListener("click",async()=>{if(confirm(`Delete network "${M.dataset.name}"?`)){M.textContent="...",M.disabled=!0;try{await deleteAPI(`/api/v1/docker/networks/${encodeURIComponent(M.dataset.id)}`),A()}catch(T){showNotification("Delete failed: "+T.message,"error"),M.textContent="Delete",M.disabled=!1}}})})}catch(g){j.innerHTML=`<div class="panel-empty" style="color: var(--bad-fg);">Failed: ${escapeHtml(g.message)}</div>`}}document.getElementById("dr-net-create")?.addEventListener("click",async()=>{const j=document.getElementById("dr-net-name"),g=document.getElementById("dr-net-driver"),$=j.value.trim();if(!$){showNotification("Enter a network name","warning");return}try{await postJSON("/api/v1/docker/networks",{name:$,driver:g.value}),j.value="",showNotification(`Network "${$}" created`,"success"),A()}catch(k){showNotification("Create failed: "+k.message,"error")}});async function D(){const j=document.getElementById("dr-disk-content");try{const g=await getJSON("/api/v1/docker/disk-usage"),$=[{label:"Images",icon:"\u{1F4C0}",count:g.images.count,size:g.images.size,reclaimable:g.images.reclaimable},{label:"Containers",icon:"\u{1F4E6}",count:g.containers.count,size:g.containers.size,extra:`${g.containers.running} running`},{label:"Volumes",icon:"\u{1F4BE}",count:g.volumes.count,size:g.volumes.size,reclaimable:g.volumes.reclaimable},{label:"Build Cache",icon:"\u{1F527}",count:g.buildCache.count,size:g.buildCache.size,reclaimable:g.buildCache.reclaimable}];let k=`<div style="font-size: 1.1rem; font-weight: 600; margin-bottom: 16px;">Total: ${h(g.totalSize)}</div>`;k+='<div style="display: grid; grid-template-columns: 1fr 1fr; gap: 12px;">';for(const M of $)k+='<div style="padding: 14px; background: var(--bg); border-radius: 8px; border: 1px solid var(--border);">',k+=`<div style="font-weight: 600; margin-bottom: 6px;">${M.icon} ${M.label} <span style="color: var(--muted); font-weight: 400; font-size: 0.82rem;">(${M.count})</span></div>`,k+=`<div style="font-size: 1.1rem; font-weight: 600; color: var(--accent);">${h(M.size)}</div>`,M.reclaimable>0&&(k+=`<div style="font-size: 0.78rem; color: var(--muted);">Reclaimable: ${h(M.reclaimable)}</div>`),M.extra&&(k+=`<div style="font-size: 0.78rem; color: var(--muted);">${M.extra}</div>`),k+="</div>";k+="</div>",j.innerHTML=k}catch(g){j.innerHTML=`<div class="panel-empty" style="color: var(--bad-fg);">Failed: ${escapeHtml(g.message)}</div>`}}E?.addEventListener("click",()=>{x?.classList.add("show"),P()}),wireModal(x,R),document.querySelector('[data-panel="dr-networks"]')?.addEventListener("click",A),document.querySelector('[data-panel="dr-disk"]')?.addEventListener("click",D)})(),(function(){injectModal("compose-import-modal",`<div id="compose-import-modal" class="weather-modal">
+  </div>`);const x=document.getElementById("docker-resources-modal"),E=document.getElementById("docker-resources-btn"),j=document.getElementById("dr-close");function h(R){if(!R||R===0)return"0 B";const y=["B","KB","MB","GB","TB"],$=Math.floor(Math.log(Math.abs(R))/Math.log(1024));return(R/Math.pow(1024,$)).toFixed(1)+" "+y[$]}async function P(){const R=document.getElementById("dr-vol-list");try{const $=(await getJSON("/api/v1/docker/volumes")).volumes||[];if($.length===0){R.innerHTML='<div class="panel-empty"><span class="empty-icon">\u{1F4E6}</span>No volumes found.</div>';return}let k='<table style="width: 100%; border-collapse: collapse; font-size: 0.82rem;">';k+='<tr style="border-bottom: 1px solid var(--border); color: var(--muted);"><th style="padding: 6px; text-align: left;">Name</th><th style="padding: 6px;">Driver</th><th style="padding: 6px;">Scope</th><th style="padding: 6px; text-align: right;">Actions</th></tr>';for(const H of $){const T=H.name==="buildkit"||H.name.length===64;k+='<tr style="border-bottom: 1px solid var(--border);">',k+=`<td style="padding: 6px; font-weight: 500; max-width: 300px; overflow: hidden; text-overflow: ellipsis; white-space: nowrap;" title="${escapeHtml(H.name)}">${escapeHtml(H.name.length>40?H.name.substring(0,37)+"...":H.name)}</td>`,k+=`<td style="padding: 6px; text-align: center; color: var(--muted);">${escapeHtml(H.driver)}</td>`,k+=`<td style="padding: 6px; text-align: center; color: var(--muted);">${escapeHtml(H.scope)}</td>`,k+='<td style="padding: 6px; text-align: right;">',T||(k+=`<button class="dr-vol-del" data-name="${escapeHtml(H.name)}" style="padding: 3px 8px; font-size: 0.75rem; color: var(--bad-fg);">Delete</button>`),k+="</td></tr>"}k+="</table>",R.innerHTML=k,R.querySelectorAll(".dr-vol-del").forEach(H=>{H.addEventListener("click",async()=>{if(confirm(`Delete volume "${H.dataset.name}"? Data will be lost.`)){H.textContent="...",H.disabled=!0;try{await deleteAPI(`/api/v1/docker/volumes/${encodeURIComponent(H.dataset.name)}?force=true`),P()}catch(T){showNotification("Delete failed: "+T.message,"error"),H.textContent="Delete",H.disabled=!1}}})})}catch(y){R.innerHTML=`<div class="panel-empty" style="color: var(--bad-fg);">Failed: ${escapeHtml(y.message)}</div>`}}document.getElementById("dr-vol-create")?.addEventListener("click",async()=>{const R=document.getElementById("dr-vol-name"),y=R.value.trim();if(!y){showNotification("Enter a volume name","warning");return}try{await postJSON("/api/v1/docker/volumes",{name:y}),R.value="",showNotification(`Volume "${y}" created`,"success"),P()}catch($){showNotification("Create failed: "+$.message,"error")}});async function A(){const R=document.getElementById("dr-net-list");try{const $=(await getJSON("/api/v1/docker/networks")).networks||[];if($.length===0){R.innerHTML='<div class="panel-empty"><span class="empty-icon">\u{1F310}</span>No networks found.</div>';return}let k='<table style="width: 100%; border-collapse: collapse; font-size: 0.82rem;">';k+='<tr style="border-bottom: 1px solid var(--border); color: var(--muted);"><th style="padding: 6px; text-align: left;">Name</th><th style="padding: 6px;">Driver</th><th style="padding: 6px;">Scope</th><th style="padding: 6px;">Containers</th><th style="padding: 6px; text-align: right;">Actions</th></tr>';for(const H of $){const T=["bridge","host","none"].includes(H.name);k+='<tr style="border-bottom: 1px solid var(--border);">',k+=`<td style="padding: 6px; font-weight: 500;">${escapeHtml(H.name)}</td>`,k+=`<td style="padding: 6px; text-align: center; color: var(--muted);">${escapeHtml(H.driver)}</td>`,k+=`<td style="padding: 6px; text-align: center; color: var(--muted);">${escapeHtml(H.scope)}</td>`,k+=`<td style="padding: 6px; text-align: center;">${H.containers}</td>`,k+='<td style="padding: 6px; text-align: right;">',T||(k+=`<button class="dr-net-del" data-id="${escapeHtml(H.id)}" data-name="${escapeHtml(H.name)}" style="padding: 3px 8px; font-size: 0.75rem; color: var(--bad-fg);">Delete</button>`),k+="</td></tr>"}k+="</table>",R.innerHTML=k,R.querySelectorAll(".dr-net-del").forEach(H=>{H.addEventListener("click",async()=>{if(confirm(`Delete network "${H.dataset.name}"?`)){H.textContent="...",H.disabled=!0;try{await deleteAPI(`/api/v1/docker/networks/${encodeURIComponent(H.dataset.id)}`),A()}catch(T){showNotification("Delete failed: "+T.message,"error"),H.textContent="Delete",H.disabled=!1}}})})}catch(y){R.innerHTML=`<div class="panel-empty" style="color: var(--bad-fg);">Failed: ${escapeHtml(y.message)}</div>`}}document.getElementById("dr-net-create")?.addEventListener("click",async()=>{const R=document.getElementById("dr-net-name"),y=document.getElementById("dr-net-driver"),$=R.value.trim();if(!$){showNotification("Enter a network name","warning");return}try{await postJSON("/api/v1/docker/networks",{name:$,driver:y.value}),R.value="",showNotification(`Network "${$}" created`,"success"),A()}catch(k){showNotification("Create failed: "+k.message,"error")}});async function D(){const R=document.getElementById("dr-disk-content");try{const y=await getJSON("/api/v1/docker/disk-usage"),$=[{label:"Images",icon:"\u{1F4C0}",count:y.images.count,size:y.images.size,reclaimable:y.images.reclaimable},{label:"Containers",icon:"\u{1F4E6}",count:y.containers.count,size:y.containers.size,extra:`${y.containers.running} running`},{label:"Volumes",icon:"\u{1F4BE}",count:y.volumes.count,size:y.volumes.size,reclaimable:y.volumes.reclaimable},{label:"Build Cache",icon:"\u{1F527}",count:y.buildCache.count,size:y.buildCache.size,reclaimable:y.buildCache.reclaimable}];let k=`<div style="font-size: 1.1rem; font-weight: 600; margin-bottom: 16px;">Total: ${h(y.totalSize)}</div>`;k+='<div style="display: grid; grid-template-columns: 1fr 1fr; gap: 12px;">';for(const H of $)k+='<div style="padding: 14px; background: var(--bg); border-radius: 8px; border: 1px solid var(--border);">',k+=`<div style="font-weight: 600; margin-bottom: 6px;">${H.icon} ${H.label} <span style="color: var(--muted); font-weight: 400; font-size: 0.82rem;">(${H.count})</span></div>`,k+=`<div style="font-size: 1.1rem; font-weight: 600; color: var(--accent);">${h(H.size)}</div>`,H.reclaimable>0&&(k+=`<div style="font-size: 0.78rem; color: var(--muted);">Reclaimable: ${h(H.reclaimable)}</div>`),H.extra&&(k+=`<div style="font-size: 0.78rem; color: var(--muted);">${H.extra}</div>`),k+="</div>";k+="</div>",R.innerHTML=k}catch(y){R.innerHTML=`<div class="panel-empty" style="color: var(--bad-fg);">Failed: ${escapeHtml(y.message)}</div>`}}E?.addEventListener("click",()=>{x?.classList.add("show"),P()}),wireModal(x,j),document.querySelector('[data-panel="dr-networks"]')?.addEventListener("click",A),document.querySelector('[data-panel="dr-disk"]')?.addEventListener("click",D)})(),(function(){injectModal("compose-import-modal",`<div id="compose-import-modal" class="weather-modal">
     <div class="weather-modal-content" style="min-width: 650px; max-width: 800px;">
       <h3>\u{1F4E6} Import Docker Compose</h3>
       <p class="modal-subtitle">Paste a docker-compose.yml to import and deploy services.</p>
@@ -1752,7 +1752,7 @@ Enter version to rollback to:`);if(!s)return;if(!e.includes(s)){showNotification
         <div id="compose-progress-content"></div>
       </div>
     </div>
-  </div>`);const x=document.getElementById("compose-import-modal"),E=document.getElementById("compose-import-btn"),R=document.getElementById("compose-cancel");wireModal(x,R);let h=null;function P(D){document.getElementById("compose-step-paste").style.display=D==="paste"?"":"none",document.getElementById("compose-step-preview").style.display=D==="preview"?"":"none",document.getElementById("compose-step-progress").style.display=D==="progress"?"":"none"}E?.addEventListener("click",()=>{P("paste"),h=null,document.getElementById("compose-yaml").value="",document.getElementById("compose-stack-name").value="",x?.classList.add("show")}),document.getElementById("compose-file-upload")?.addEventListener("change",D=>{const j=D.target.files[0];if(!j)return;const g=new FileReader;g.onload=()=>{document.getElementById("compose-yaml").value=g.result},g.readAsText(j)}),document.getElementById("compose-parse-btn")?.addEventListener("click",async()=>{const D=document.getElementById("compose-yaml").value.trim(),j=document.getElementById("compose-stack-name").value.trim()||"stack";if(!D){showNotification("Paste a docker-compose.yml","warning");return}const g=document.getElementById("compose-parse-btn"),$=g.textContent;g.textContent="Parsing...",g.disabled=!0;try{const k=await postJSON("/api/v1/apps/import-compose",{yaml:D,stackName:j});h=k,h.stackName=j,A(k),P("preview")}catch(k){showNotification("Parse failed: "+k.message,"error")}finally{g.textContent=$,g.disabled=!1}});function A(D){const j=document.getElementById("compose-preview-content");let g="";D.networks&&D.networks.length>0&&(g+=`<div style="margin-bottom: 12px; font-size: 0.82rem; color: var(--muted);">Networks: ${D.networks.map($=>`<code>${escapeHtml($)}</code>`).join(", ")}</div>`),D.volumes&&D.volumes.length>0&&(g+=`<div style="margin-bottom: 12px; font-size: 0.82rem; color: var(--muted);">Volumes: ${D.volumes.map($=>`<code>${escapeHtml($)}</code>`).join(", ")}</div>`),g+=`<div style="font-weight: 600; margin-bottom: 8px;">${D.services.length} service(s)</div>`,g+='<div class="scroll-container" style="max-height: 350px;">';for(const $ of D.services){const k=$.skip?"var(--bad-fg)":"var(--border)";if(g+=`<div style="padding: 10px 14px; border: 1px solid ${k}; border-radius: 8px; margin-bottom: 8px; background: var(--bg);">`,g+=`<div style="font-weight: 600; font-size: 0.9rem;">${escapeHtml($.name)}`,$.skip&&(g+=` <span style="color: var(--bad-fg); font-weight: 400; font-size: 0.78rem;">\u2014 skipped: ${escapeHtml($.reason)}</span>`),g+="</div>",!$.skip&&(g+=`<div style="font-size: 0.8rem; color: var(--muted); margin-top: 4px;">Image: <code>${escapeHtml($.image)}</code></div>`,$.ports?.length&&(g+=`<div style="font-size: 0.8rem; color: var(--muted);">Ports: ${$.ports.map(M=>`${M.host}:${M.container}`).join(", ")}</div>`),$.volumes?.length&&(g+=`<div style="font-size: 0.8rem; color: var(--muted);">Volumes: ${$.volumes.length}</div>`),Object.keys($.environment||{}).length&&(g+=`<div style="font-size: 0.8rem; color: var(--muted);">Env vars: ${Object.keys($.environment).length}</div>`),$.envFileWarning&&(g+=`<div style="font-size: 0.78rem; color: var(--bad-fg);">\u26A0 ${escapeHtml($.envFileWarning)}</div>`),$.resources?.cpus||$.resources?.memory)){const M=[];$.resources.cpus&&M.push(`CPU: ${$.resources.cpus}`),$.resources.memory&&M.push(`Mem: ${$.resources.memory}MB`),g+=`<div style="font-size: 0.8rem; color: var(--muted);">Limits: ${M.join(", ")}</div>`}g+="</div>"}g+="</div>",j.innerHTML=g}document.getElementById("compose-back-btn")?.addEventListener("click",()=>P("paste")),document.getElementById("compose-deploy-btn")?.addEventListener("click",async()=>{if(!h)return;const D=document.getElementById("compose-deploy-btn");D.textContent="Deploying...",D.disabled=!0,P("progress");const j=document.getElementById("compose-progress-content");j.innerHTML='<div class="panel-empty"><span class="brand-spinner"></span> Deploying services...</div>';try{const g=await postJSON("/api/v1/apps/deploy-compose",{services:h.services,networks:h.networks,stackName:h.stackName});let $=`<div style="font-weight: 600; margin-bottom: 12px;">Stack "${escapeHtml(g.stackName)}" \u2014 Deployment Complete</div>`;$+='<div class="scroll-container" style="max-height: 350px;">';for(const k of g.results){const M=k.status==="deployed"||k.status==="created"?"\u2705":k.status==="exists"?"\u26A1":k.status==="skipped"?"\u23ED":"\u274C";$+='<div style="padding: 8px 12px; border-bottom: 1px solid var(--border); font-size: 0.85rem;">',$+=`${M} <strong>${escapeHtml(k.name)}</strong> (${k.type}) \u2014 ${escapeHtml(k.status)}`,k.error&&($+=` <span style="color: var(--bad-fg);">${escapeHtml(k.error)}</span>`),k.subdomain&&($+=` \u2192 <code>${escapeHtml(k.subdomain)}</code>`),k.reason&&($+=` <span style="color: var(--muted);">(${escapeHtml(k.reason)})</span>`),$+="</div>"}$+="</div>",$+='<div class="weather-modal-buttons modal-footer-bar" style="margin-top: 16px;"><button id="compose-done-btn">Done</button></div>',j.innerHTML=$,document.getElementById("compose-done-btn")?.addEventListener("click",()=>{x?.classList.remove("show"),typeof window.loadServices=="function"&&window.loadServices().then(()=>{typeof window.buildGrid=="function"&&window.buildGrid()})}),showNotification(`Stack "${g.stackName}" deployed`,"success")}catch(g){j.innerHTML=`<div class="panel-empty" style="color: var(--bad-fg);">Deployment failed: ${escapeHtml(g.message)}</div>
+  </div>`);const x=document.getElementById("compose-import-modal"),E=document.getElementById("compose-import-btn"),j=document.getElementById("compose-cancel");wireModal(x,j);let h=null;function P(D){document.getElementById("compose-step-paste").style.display=D==="paste"?"":"none",document.getElementById("compose-step-preview").style.display=D==="preview"?"":"none",document.getElementById("compose-step-progress").style.display=D==="progress"?"":"none"}E?.addEventListener("click",()=>{P("paste"),h=null,document.getElementById("compose-yaml").value="",document.getElementById("compose-stack-name").value="",x?.classList.add("show")}),document.getElementById("compose-file-upload")?.addEventListener("change",D=>{const R=D.target.files[0];if(!R)return;const y=new FileReader;y.onload=()=>{document.getElementById("compose-yaml").value=y.result},y.readAsText(R)}),document.getElementById("compose-parse-btn")?.addEventListener("click",async()=>{const D=document.getElementById("compose-yaml").value.trim(),R=document.getElementById("compose-stack-name").value.trim()||"stack";if(!D){showNotification("Paste a docker-compose.yml","warning");return}const y=document.getElementById("compose-parse-btn"),$=y.textContent;y.textContent="Parsing...",y.disabled=!0;try{const k=await postJSON("/api/v1/apps/import-compose",{yaml:D,stackName:R});h=k,h.stackName=R,A(k),P("preview")}catch(k){showNotification("Parse failed: "+k.message,"error")}finally{y.textContent=$,y.disabled=!1}});function A(D){const R=document.getElementById("compose-preview-content");let y="";D.networks&&D.networks.length>0&&(y+=`<div style="margin-bottom: 12px; font-size: 0.82rem; color: var(--muted);">Networks: ${D.networks.map($=>`<code>${escapeHtml($)}</code>`).join(", ")}</div>`),D.volumes&&D.volumes.length>0&&(y+=`<div style="margin-bottom: 12px; font-size: 0.82rem; color: var(--muted);">Volumes: ${D.volumes.map($=>`<code>${escapeHtml($)}</code>`).join(", ")}</div>`),y+=`<div style="font-weight: 600; margin-bottom: 8px;">${D.services.length} service(s)</div>`,y+='<div class="scroll-container" style="max-height: 350px;">';for(const $ of D.services){const k=$.skip?"var(--bad-fg)":"var(--border)";if(y+=`<div style="padding: 10px 14px; border: 1px solid ${k}; border-radius: 8px; margin-bottom: 8px; background: var(--bg);">`,y+=`<div style="font-weight: 600; font-size: 0.9rem;">${escapeHtml($.name)}`,$.skip&&(y+=` <span style="color: var(--bad-fg); font-weight: 400; font-size: 0.78rem;">\u2014 skipped: ${escapeHtml($.reason)}</span>`),y+="</div>",!$.skip&&(y+=`<div style="font-size: 0.8rem; color: var(--muted); margin-top: 4px;">Image: <code>${escapeHtml($.image)}</code></div>`,$.ports?.length&&(y+=`<div style="font-size: 0.8rem; color: var(--muted);">Ports: ${$.ports.map(H=>`${H.host}:${H.container}`).join(", ")}</div>`),$.volumes?.length&&(y+=`<div style="font-size: 0.8rem; color: var(--muted);">Volumes: ${$.volumes.length}</div>`),Object.keys($.environment||{}).length&&(y+=`<div style="font-size: 0.8rem; color: var(--muted);">Env vars: ${Object.keys($.environment).length}</div>`),$.envFileWarning&&(y+=`<div style="font-size: 0.78rem; color: var(--bad-fg);">\u26A0 ${escapeHtml($.envFileWarning)}</div>`),$.resources?.cpus||$.resources?.memory)){const H=[];$.resources.cpus&&H.push(`CPU: ${$.resources.cpus}`),$.resources.memory&&H.push(`Mem: ${$.resources.memory}MB`),y+=`<div style="font-size: 0.8rem; color: var(--muted);">Limits: ${H.join(", ")}</div>`}y+="</div>"}y+="</div>",R.innerHTML=y}document.getElementById("compose-back-btn")?.addEventListener("click",()=>P("paste")),document.getElementById("compose-deploy-btn")?.addEventListener("click",async()=>{if(!h)return;const D=document.getElementById("compose-deploy-btn");D.textContent="Deploying...",D.disabled=!0,P("progress");const R=document.getElementById("compose-progress-content");R.innerHTML='<div class="panel-empty"><span class="brand-spinner"></span> Deploying services...</div>';try{const y=await postJSON("/api/v1/apps/deploy-compose",{services:h.services,networks:h.networks,stackName:h.stackName});let $=`<div style="font-weight: 600; margin-bottom: 12px;">Stack "${escapeHtml(y.stackName)}" \u2014 Deployment Complete</div>`;$+='<div class="scroll-container" style="max-height: 350px;">';for(const k of y.results){const H=k.status==="deployed"||k.status==="created"?"\u2705":k.status==="exists"?"\u26A1":k.status==="skipped"?"\u23ED":"\u274C";$+='<div style="padding: 8px 12px; border-bottom: 1px solid var(--border); font-size: 0.85rem;">',$+=`${H} <strong>${escapeHtml(k.name)}</strong> (${k.type}) \u2014 ${escapeHtml(k.status)}`,k.error&&($+=` <span style="color: var(--bad-fg);">${escapeHtml(k.error)}</span>`),k.subdomain&&($+=` \u2192 <code>${escapeHtml(k.subdomain)}</code>`),k.reason&&($+=` <span style="color: var(--muted);">(${escapeHtml(k.reason)})</span>`),$+="</div>"}$+="</div>",$+='<div class="weather-modal-buttons modal-footer-bar" style="margin-top: 16px;"><button id="compose-done-btn">Done</button></div>',R.innerHTML=$,document.getElementById("compose-done-btn")?.addEventListener("click",()=>{x?.classList.remove("show"),typeof window.loadServices=="function"&&window.loadServices().then(()=>{typeof window.buildGrid=="function"&&window.buildGrid()})}),showNotification(`Stack "${y.stackName}" deployed`,"success")}catch(y){R.innerHTML=`<div class="panel-empty" style="color: var(--bad-fg);">Deployment failed: ${escapeHtml(y.message)}</div>
         <div class="weather-modal-buttons modal-footer-bar" style="margin-top: 16px;"><button id="compose-retry-btn">Back</button></div>`,document.getElementById("compose-retry-btn")?.addEventListener("click",()=>P("paste"))}finally{D.textContent="Deploy All",D.disabled=!1}})})(),(function(){injectModal("exec-modal",`<div id="exec-modal" class="weather-modal">
     <div class="weather-modal-content" style="min-width: 700px; max-width: 900px; padding-bottom: 0;">
       <h3 id="exec-title">Terminal</h3>
@@ -1761,11 +1761,11 @@ Enter version to rollback to:`);if(!s)return;if(!e.includes(s)){showNotification
         <button id="exec-close">Close</button>
       </div>
     </div>
-  </div>`);const x=document.getElementById("exec-modal"),E=document.getElementById("exec-terminal"),R=document.getElementById("exec-close");let h=null,P=null,A=null;function D(){if(P){try{P.close()}catch{}P=null}if(h){try{h.dispose()}catch{}h=null}A=null,E.innerHTML=""}function j(g,$){if(D(),document.getElementById("exec-title").textContent=`Terminal \u2014 ${$||g}`,x?.classList.add("show"),typeof Terminal>"u"){E.innerHTML='<div style="color: #f44; padding: 20px; font-family: monospace;">xterm.js not loaded</div>';return}h=new Terminal({cursorBlink:!0,fontSize:14,fontFamily:"'Cascadia Code', 'Fira Code', 'Consolas', monospace",theme:{background:"#1e1e1e",foreground:"#d4d4d4",cursor:"#aeafad",selectionBackground:"#264f78"},scrollback:5e3}),typeof FitAddon<"u"&&(A=new FitAddon.FitAddon,h.loadAddon(A)),h.open(E),A&&setTimeout(()=>A.fit(),50);const k=location.protocol==="https:"?"wss:":"ws:";P=new WebSocket(`${k}//${location.host}/ws/exec/${encodeURIComponent(g)}`),P.binaryType="arraybuffer",P.onopen=()=>{if(h.writeln("\x1B[32mConnecting...\x1B[0m"),A){const T=A.proposeDimensions();T&&P.send(JSON.stringify({type:"resize",cols:T.cols,rows:T.rows}))}},P.onmessage=T=>{if(typeof T.data=="string"){try{const z=JSON.parse(T.data);if(z.type==="connected"){h.writeln(`\x1B[32mConnected (${z.shell})\x1B[0m\r
+  </div>`);const x=document.getElementById("exec-modal"),E=document.getElementById("exec-terminal"),j=document.getElementById("exec-close");let h=null,P=null,A=null;function D(){if(P){try{P.close()}catch{}P=null}if(h){try{h.dispose()}catch{}h=null}A=null,E.innerHTML=""}function R(y,$){if(D(),document.getElementById("exec-title").textContent=`Terminal \u2014 ${$||y}`,x?.classList.add("show"),typeof Terminal>"u"){E.innerHTML='<div style="color: #f44; padding: 20px; font-family: monospace;">xterm.js not loaded</div>';return}h=new Terminal({cursorBlink:!0,fontSize:14,fontFamily:"'Cascadia Code', 'Fira Code', 'Consolas', monospace",theme:{background:"#1e1e1e",foreground:"#d4d4d4",cursor:"#aeafad",selectionBackground:"#264f78"},scrollback:5e3}),typeof FitAddon<"u"&&(A=new FitAddon.FitAddon,h.loadAddon(A)),h.open(E),A&&setTimeout(()=>A.fit(),50);const k=location.protocol==="https:"?"wss:":"ws:";P=new WebSocket(`${k}//${location.host}/ws/exec/${encodeURIComponent(y)}`),P.binaryType="arraybuffer",P.onopen=()=>{if(h.writeln("\x1B[32mConnecting...\x1B[0m"),A){const T=A.proposeDimensions();T&&P.send(JSON.stringify({type:"resize",cols:T.cols,rows:T.rows}))}},P.onmessage=T=>{if(typeof T.data=="string"){try{const z=JSON.parse(T.data);if(z.type==="connected"){h.writeln(`\x1B[32mConnected (${z.shell})\x1B[0m\r
 `);return}if(z.type==="error"){h.writeln(`\x1B[31mError: ${z.message}\x1B[0m`);return}if(z.type==="exit"){h.writeln(`\r
 \x1B[33mSession ended.\x1B[0m`);return}}catch{}h.write(T.data)}else h.write(new Uint8Array(T.data))},P.onclose=()=>{h&&h.writeln(`\r
 \x1B[33mDisconnected.\x1B[0m`)},P.onerror=()=>{h&&h.writeln(`\r
-\x1B[31mConnection error.\x1B[0m`)},h.onData(T=>{P&&P.readyState===WebSocket.OPEN&&P.send(T)}),h.onResize(({cols:T,rows:z})=>{P&&P.readyState===WebSocket.OPEN&&P.send(JSON.stringify({type:"resize",cols:T,rows:z}))});const M=()=>{A&&A.fit()};window.addEventListener("resize",M),x._resizeHandler=M}R?.addEventListener("click",()=>{D(),x._resizeHandler&&window.removeEventListener("resize",x._resizeHandler),x?.classList.remove("show")}),x?.addEventListener("click",g=>{g.target===x&&(D(),x._resizeHandler&&window.removeEventListener("resize",x._resizeHandler),x?.classList.remove("show"))}),window.openExecModal=j})(),(function(){injectModal("audit-modal",`<div id="audit-modal" class="weather-modal">
+\x1B[31mConnection error.\x1B[0m`)},h.onData(T=>{P&&P.readyState===WebSocket.OPEN&&P.send(T)}),h.onResize(({cols:T,rows:z})=>{P&&P.readyState===WebSocket.OPEN&&P.send(JSON.stringify({type:"resize",cols:T,rows:z}))});const H=()=>{A&&A.fit()};window.addEventListener("resize",H),x._resizeHandler=H}j?.addEventListener("click",()=>{D(),x._resizeHandler&&window.removeEventListener("resize",x._resizeHandler),x?.classList.remove("show")}),x?.addEventListener("click",y=>{y.target===x&&(D(),x._resizeHandler&&window.removeEventListener("resize",x._resizeHandler),x?.classList.remove("show"))}),window.openExecModal=R})(),(function(){injectModal("audit-modal",`<div id="audit-modal" class="weather-modal">
     <div class="weather-modal-content" style="min-width: 950px; max-width: 1150px;">
       <h3>\u{1F4DC} Audit Log</h3>
       <p class="modal-subtitle">
@@ -1811,7 +1811,7 @@ Enter version to rollback to:`);if(!s)return;if(!e.includes(s)){showNotification
         <button id="audit-cancel">Close</button>
       </div>
     </div>
-  </div>`);const x=document.getElementById("audit-modal"),E=document.getElementById("audit-log-btn"),R=document.getElementById("audit-cancel"),h=document.getElementById("audit-refresh-btn"),P=document.getElementById("audit-clear-btn"),A=document.getElementById("audit-filter"),D=document.getElementById("audit-outcome-filter"),j=document.getElementById("audit-since"),g=document.getElementById("audit-until"),$=document.getElementById("audit-log-container"),k=document.getElementById("audit-load-more");let M=0,T=null,z=0;const C=50;function H(S){if(!S)return null;const O=new Date(S);return isNaN(O.getTime())?null:O.toISOString()}async function b(S){try{S?(T&&T.abort(),T=new AbortController):(T&&T.abort(),T=new AbortController,M=0,z++,$.innerHTML='<div class="panel-empty"><span class="brand-spinner"></span> Loading...</div>');const O=z,m=new URLSearchParams;m.set("limit",String(C)),m.set("offset",String(M));const f=A.value,B=D.value,w=H(j.value),L=H(g.value);f&&m.set("action",f),B&&m.set("outcome",B),w&&m.set("since",w),L&&m.set("until",L);const o=await fetch("/api/v1/audit-logs?"+m.toString(),{signal:T.signal});if(!o.ok){$.innerHTML=`<div class="panel-empty" style="color: var(--bad-fg);">Failed: HTTP ${o.status}</div>`,k.style.display="none";return}const p=await o.json();if(!p.success){$.innerHTML=`<div class="panel-empty" style="color: var(--bad-fg);">Failed: ${escapeHtml(p.error||"unknown")}</div>`,k.style.display="none";return}if(!S&&O!==z)return;const l=Array.isArray(p.entries)?p.entries:[];if(l.length===0&&!S){const u=p.filters&&(p.filters.action||p.filters.outcome||p.filters.since||p.filters.until)?"No entries match your filters.":"No audit log entries yet. Actions will be logged automatically.";$.innerHTML=`<div class="panel-empty"><span class="empty-icon">\u{1F4DC}</span>${escapeHtml(u)}</div>`,k.style.display="none";return}let y="";S||(y='<table style="width: 100%; border-collapse: collapse; font-size: 0.82rem;">',y+='<tr style="border-bottom: 1px solid var(--border); color: var(--muted);">',y+='<th style="padding: 6px; text-align: left;">When</th>',y+='<th style="padding: 6px; text-align: left;">Actor</th>',y+='<th style="padding: 6px; text-align: left;">IP</th>',y+='<th style="padding: 6px; text-align: left;">Action</th>',y+='<th style="padding: 6px; text-align: left;">Resource</th>',y+='<th style="padding: 6px; text-align: left;">Result</th>',y+="</tr>");for(const u of l){const t=u.outcome==="success",e=d(u);y+='<tr style="border-bottom: 1px solid var(--border); cursor: pointer;" class="audit-row">',y+=`<td style="padding: 6px; color: var(--muted);" title="${escapeHtml(u.timestamp||"")}">${timeAgo(u.timestamp)}</td>`,y+=`<td style="padding: 6px; font-size: 0.78rem;">${e}</td>`,y+=`<td style="padding: 6px; font-family: monospace; font-size: 0.78rem;">${escapeHtml(u.ip||"-")}</td>`,y+=`<td style="padding: 6px; font-weight: 500;">${escapeHtml(u.action||"-")}</td>`,y+=`<td style="padding: 6px;">${escapeHtml(u.resource||"-")}</td>`,y+=`<td style="padding: 6px;"><span style="color: ${t?"var(--ok-fg)":"var(--bad-fg)"};">${t?"\u2713":"\u2717"} ${escapeHtml(u.outcome||"")}</span></td>`,y+="</tr>",u.details&&Object.keys(u.details).length>0&&(y+=`<tr class="audit-detail" style="display: none;"><td colspan="6" style="padding: 6px 6px 10px; font-size: 0.78rem; color: var(--muted);"><pre style="margin: 0; white-space: pre-wrap; font-family: monospace;">${escapeHtml(JSON.stringify(u.details,null,2))}</pre></td></tr>`)}if(!S)y+="</table>",$.innerHTML=y;else{const u=$.querySelector("table");u&&u.insertAdjacentHTML("beforeend",y)}M+=l.length,k.style.display=p.hasMore?"":"none",$.querySelectorAll(".audit-row").forEach(u=>{u.dataset.wired||(u.dataset.wired="true",u.addEventListener("click",()=>{const t=u.nextElementSibling;t&&t.classList.contains("audit-detail")&&(t.style.display=t.style.display==="none"?"":"none")}))})}catch(O){if(O&&O.name==="AbortError")return;$.innerHTML=`<div class="panel-empty" style="color: var(--bad-fg);">Failed: ${escapeHtml(O.message)}</div>`}}function d(S){const O=S.details||{},m=O.userEmail,f=O.userId,B=O.userRole,w=O.viaProvider;if(m){const L=B?` <span style="color: var(--muted); font-size: 0.72rem;">[${escapeHtml(B)}${w?"/"+escapeHtml(w):""}]</span>`:"";return`${escapeHtml(m)}${L}`}return f?`<span style="font-family: monospace; color: var(--muted);">${escapeHtml(f)}</span>`:S.ip?'<span style="color: var(--muted);">anon</span>':'<span style="color: var(--muted);">system</span>'}E?.addEventListener("click",()=>{x?.classList.add("show"),b(!1)}),wireModal(x,R),h?.addEventListener("click",()=>b(!1)),A?.addEventListener("change",()=>b(!1)),D?.addEventListener("change",()=>b(!1));let v;[j,g].forEach(S=>{S?.addEventListener("change",()=>{clearTimeout(v),v=setTimeout(()=>b(!1),250)})}),k?.addEventListener("click",()=>b(!0)),P?.addEventListener("click",async()=>{if(confirm("Clear the entire audit log? This cannot be undone."))try{const O=await(await secureFetch("/api/v1/audit-logs",{method:"DELETE",headers:{"content-type":"application/json"},body:JSON.stringify({confirm:"CLEAR"})})).json();O.success?b(!1):showNotification("Error: "+(O.error||"Clear failed"),"error")}catch(S){showNotification("Error: "+S.message,"error")}})})(),(function(){injectModal("security-modal",`<div id="security-modal" class="weather-modal">
+  </div>`);const x=document.getElementById("audit-modal"),E=document.getElementById("audit-log-btn"),j=document.getElementById("audit-cancel"),h=document.getElementById("audit-refresh-btn"),P=document.getElementById("audit-clear-btn"),A=document.getElementById("audit-filter"),D=document.getElementById("audit-outcome-filter"),R=document.getElementById("audit-since"),y=document.getElementById("audit-until"),$=document.getElementById("audit-log-container"),k=document.getElementById("audit-load-more");let H=0,T=null,z=0;const C=50;function M(S){if(!S)return null;const O=new Date(S);return isNaN(O.getTime())?null:O.toISOString()}async function b(S){try{S?(T&&T.abort(),T=new AbortController):(T&&T.abort(),T=new AbortController,H=0,z++,$.innerHTML='<div class="panel-empty"><span class="brand-spinner"></span> Loading...</div>');const O=z,m=new URLSearchParams;m.set("limit",String(C)),m.set("offset",String(H));const f=A.value,B=D.value,w=M(R.value),L=M(y.value);f&&m.set("action",f),B&&m.set("outcome",B),w&&m.set("since",w),L&&m.set("until",L);const o=await fetch("/api/v1/audit-logs?"+m.toString(),{signal:T.signal});if(!o.ok){$.innerHTML=`<div class="panel-empty" style="color: var(--bad-fg);">Failed: HTTP ${o.status}</div>`,k.style.display="none";return}const u=await o.json();if(!u.success){$.innerHTML=`<div class="panel-empty" style="color: var(--bad-fg);">Failed: ${escapeHtml(u.error||"unknown")}</div>`,k.style.display="none";return}if(!S&&O!==z)return;const l=Array.isArray(u.entries)?u.entries:[];if(l.length===0&&!S){const p=u.filters&&(u.filters.action||u.filters.outcome||u.filters.since||u.filters.until)?"No entries match your filters.":"No audit log entries yet. Actions will be logged automatically.";$.innerHTML=`<div class="panel-empty"><span class="empty-icon">\u{1F4DC}</span>${escapeHtml(p)}</div>`,k.style.display="none";return}let g="";S||(g='<table style="width: 100%; border-collapse: collapse; font-size: 0.82rem;">',g+='<tr style="border-bottom: 1px solid var(--border); color: var(--muted);">',g+='<th style="padding: 6px; text-align: left;">When</th>',g+='<th style="padding: 6px; text-align: left;">Actor</th>',g+='<th style="padding: 6px; text-align: left;">IP</th>',g+='<th style="padding: 6px; text-align: left;">Action</th>',g+='<th style="padding: 6px; text-align: left;">Resource</th>',g+='<th style="padding: 6px; text-align: left;">Result</th>',g+="</tr>");for(const p of l){const t=p.outcome==="success",e=d(p);g+='<tr style="border-bottom: 1px solid var(--border); cursor: pointer;" class="audit-row">',g+=`<td style="padding: 6px; color: var(--muted);" title="${escapeHtml(p.timestamp||"")}">${timeAgo(p.timestamp)}</td>`,g+=`<td style="padding: 6px; font-size: 0.78rem;">${e}</td>`,g+=`<td style="padding: 6px; font-family: monospace; font-size: 0.78rem;">${escapeHtml(p.ip||"-")}</td>`,g+=`<td style="padding: 6px; font-weight: 500;">${escapeHtml(p.action||"-")}</td>`,g+=`<td style="padding: 6px;">${escapeHtml(p.resource||"-")}</td>`,g+=`<td style="padding: 6px;"><span style="color: ${t?"var(--ok-fg)":"var(--bad-fg)"};">${t?"\u2713":"\u2717"} ${escapeHtml(p.outcome||"")}</span></td>`,g+="</tr>",p.details&&Object.keys(p.details).length>0&&(g+=`<tr class="audit-detail" style="display: none;"><td colspan="6" style="padding: 6px 6px 10px; font-size: 0.78rem; color: var(--muted);"><pre style="margin: 0; white-space: pre-wrap; font-family: monospace;">${escapeHtml(JSON.stringify(p.details,null,2))}</pre></td></tr>`)}if(!S)g+="</table>",$.innerHTML=g;else{const p=$.querySelector("table");p&&p.insertAdjacentHTML("beforeend",g)}H+=l.length,k.style.display=u.hasMore?"":"none",$.querySelectorAll(".audit-row").forEach(p=>{p.dataset.wired||(p.dataset.wired="true",p.addEventListener("click",()=>{const t=p.nextElementSibling;t&&t.classList.contains("audit-detail")&&(t.style.display=t.style.display==="none"?"":"none")}))})}catch(O){if(O&&O.name==="AbortError")return;$.innerHTML=`<div class="panel-empty" style="color: var(--bad-fg);">Failed: ${escapeHtml(O.message)}</div>`}}function d(S){const O=S.details||{},m=O.userEmail,f=O.userId,B=O.userRole,w=O.viaProvider;if(m){const L=B?` <span style="color: var(--muted); font-size: 0.72rem;">[${escapeHtml(B)}${w?"/"+escapeHtml(w):""}]</span>`:"";return`${escapeHtml(m)}${L}`}return f?`<span style="font-family: monospace; color: var(--muted);">${escapeHtml(f)}</span>`:S.ip?'<span style="color: var(--muted);">anon</span>':'<span style="color: var(--muted);">system</span>'}E?.addEventListener("click",()=>{x?.classList.add("show"),b(!1)}),wireModal(x,j),h?.addEventListener("click",()=>b(!1)),A?.addEventListener("change",()=>b(!1)),D?.addEventListener("change",()=>b(!1));let v;[R,y].forEach(S=>{S?.addEventListener("change",()=>{clearTimeout(v),v=setTimeout(()=>b(!1),250)})}),k?.addEventListener("click",()=>b(!0)),P?.addEventListener("click",async()=>{if(confirm("Clear the entire audit log? This cannot be undone."))try{const O=await(await secureFetch("/api/v1/audit-logs",{method:"DELETE",headers:{"content-type":"application/json"},body:JSON.stringify({confirm:"CLEAR"})})).json();O.success?b(!1):showNotification("Error: "+(O.error||"Clear failed"),"error")}catch(S){showNotification("Error: "+S.message,"error")}})})(),(function(){injectModal("security-modal",`<div id="security-modal" class="weather-modal">
     <div class="weather-modal-content" style="min-width: 980px; max-width: 1280px;">
       <h3>\u{1F6E1}\uFE0F Security Center</h3>
       <p class="modal-subtitle">
@@ -1890,39 +1890,39 @@ Enter version to rollback to:`);if(!s)return;if(!e.includes(s)){showNotification
         <button id="sec-cancel">Close</button>
       </div>
     </div>
-  </div>`);const x=document.getElementById("security-modal"),E=document.getElementById("security-center-btn"),R=document.getElementById("sec-cancel"),h=x.querySelectorAll(".sec-tab"),P=x.querySelectorAll(".sec-panel");let A=[],D=[],j=null;h.forEach(o=>{o.addEventListener("click",()=>{h.forEach(p=>p.classList.toggle("active",p===o)),P.forEach(p=>p.style.display=p.dataset.panel===o.dataset.tab?"":"none"),o.dataset.tab==="overview"&&M(),o.dataset.tab==="events"&&v(),o.dataset.tab==="hosts"&&f()})}),E&&E.addEventListener("click",()=>{x.classList.add("show"),M(),$()}),R.addEventListener("click",g),x.addEventListener("click",o=>{o.target===x&&g()});function g(){x.classList.remove("show"),k()}function $(){if(k(),!!document.getElementById("sec-live-tail").checked&&!(typeof EventSource>"u"))try{j=new EventSource("/api/v1/security/events/stream"),j.addEventListener("init",o=>{try{A=JSON.parse(o.data).events||[],S()}catch{}}),j.addEventListener("security",o=>{try{const p=JSON.parse(o.data);A.unshift(p),A.length>500&&(A.length=500);const l=x.querySelector(".sec-tab.active")?.dataset?.tab;l==="events"?S():l==="overview"&&M()}catch{}}),j.onerror=()=>{}}catch(o){console.warn("[security] SSE failed:",o.message)}}function k(){if(j){try{j.close()}catch{}j=null}}document.getElementById("sec-live-tail").addEventListener("change",()=>{x.classList.contains("show")&&$()});async function M(){try{const o=new Date(Date.now()-864e5).toISOString(),[p,l,y]=await Promise.all([fetch(`/api/v1/security/events/stats?since=${encodeURIComponent(o)}`),fetch("/api/v1/security/hosts"),fetch(`/api/v1/security/events?limit=1&since=${encodeURIComponent(o)}`)]),u=(await p.json()).data||{},t=(await l.json()).data?.hosts||[],e=(await y.json()).data?.total||0;document.querySelector('#sec-stats [data-key="total"]').textContent=`${e} events (24h)`,document.querySelector('#sec-stats [data-key="warn"]').textContent=`${u.by_severity?.warn||0} warnings`,document.querySelector('#sec-stats [data-key="error"]').textContent=`${u.by_severity?.error||0} errors`,document.querySelector('#sec-stats [data-key="denied"]').textContent=`${u.by_outcome?.denied||0} denied`,document.querySelector('#sec-stats [data-key="hosts"]').textContent=`${t.length} hosts`,T("sec-top-actors",u.top_actors||[]),T("sec-top-targets",u.top_targets||[])}catch(o){console.warn("[security] refreshOverview failed:",o.message)}}function T(o,p){const l=document.getElementById(o);if(!p.length){l.innerHTML='<div class="panel-empty">No data</div>';return}l.innerHTML='<table style="width:100%;font-size:0.85rem;">'+p.map(y=>`<tr><td style="padding:3px 0;word-break:break-all;">${w(String(y.key))}</td><td style="text-align:right;color:var(--muted);">${y.count}</td></tr>`).join("")+"</table>"}const z=document.getElementById("sec-filter-source"),C=document.getElementById("sec-filter-severity"),H=document.getElementById("sec-filter-host"),b=document.getElementById("sec-filter-actor"),d=document.getElementById("sec-refresh-btn");[z,C,H].forEach(o=>o.addEventListener("change",v)),b.addEventListener("input",L(v,250)),d.addEventListener("click",v);async function v(){try{const o=new URLSearchParams;o.set("limit","200"),z.value&&o.set("source_type",z.value),C.value&&o.set("severity",C.value),H.value&&o.set("source_host",H.value),b.value&&o.set("actor_prefix",b.value),A=(await(await fetch(`/api/v1/security/events?${o}`)).json()).data.events||[],S(),(!H.options.length||H.options.length===1)&&await m()}catch(o){document.getElementById("sec-events-container").innerHTML='<div class="panel-empty">Load failed: '+w(o.message)+"</div>"}}function S(){const o=document.getElementById("sec-events-container");if(!A.length){o.innerHTML='<div class="panel-empty">No events</div>';return}o.innerHTML=A.slice(0,200).map(O).join("")}function O(o){const p=o.severity||"info",l={critical:"#c0392b",error:"#e74c3c",warn:"#f39c12",notice:"#3498db",info:"#7f8c8d"}[p]||"#7f8c8d",y=o.ts?new Date(o.ts).toLocaleTimeString():"",u=o.source_type||"",t=o.actor||"\u2014",e=o.target||"",s=o.action||"",n=o.outcome||"";return`<div class="sec-event-row" style="display:grid;grid-template-columns:84px 80px 1fr 1fr 100px 90px;gap:8px;padding:5px 8px;border-bottom:1px solid var(--border);font-size:0.82rem;align-items:center;">
-      <span style="color:${l};font-weight:600;">${w(p)}</span>
-      <span style="color:var(--muted);font-size:0.75rem;">${w(u)}</span>
+  </div>`);const x=document.getElementById("security-modal"),E=document.getElementById("security-center-btn"),j=document.getElementById("sec-cancel"),h=x.querySelectorAll(".sec-tab"),P=x.querySelectorAll(".sec-panel");let A=[],D=[],R=null;h.forEach(o=>{o.addEventListener("click",()=>{h.forEach(u=>u.classList.toggle("active",u===o)),P.forEach(u=>u.style.display=u.dataset.panel===o.dataset.tab?"":"none"),o.dataset.tab==="overview"&&H(),o.dataset.tab==="events"&&v(),o.dataset.tab==="hosts"&&f()})}),E&&E.addEventListener("click",()=>{x.classList.add("show"),H(),$()}),j.addEventListener("click",y),x.addEventListener("click",o=>{o.target===x&&y()});function y(){x.classList.remove("show"),k()}function $(){if(k(),!!document.getElementById("sec-live-tail").checked&&!(typeof EventSource>"u"))try{R=new EventSource("/api/v1/security/events/stream"),R.addEventListener("init",o=>{try{A=JSON.parse(o.data).events||[],S()}catch{}}),R.addEventListener("security",o=>{try{const u=JSON.parse(o.data);A.unshift(u),A.length>500&&(A.length=500);const l=x.querySelector(".sec-tab.active")?.dataset?.tab;l==="events"?S():l==="overview"&&H()}catch{}}),R.onerror=()=>{}}catch(o){console.warn("[security] SSE failed:",o.message)}}function k(){if(R){try{R.close()}catch{}R=null}}document.getElementById("sec-live-tail").addEventListener("change",()=>{x.classList.contains("show")&&$()});async function H(){try{const o=new Date(Date.now()-864e5).toISOString(),[u,l,g]=await Promise.all([fetch(`/api/v1/security/events/stats?since=${encodeURIComponent(o)}`),fetch("/api/v1/security/hosts"),fetch(`/api/v1/security/events?limit=1&since=${encodeURIComponent(o)}`)]),p=(await u.json()).data||{},t=(await l.json()).data?.hosts||[],e=(await g.json()).data?.total||0;document.querySelector('#sec-stats [data-key="total"]').textContent=`${e} events (24h)`,document.querySelector('#sec-stats [data-key="warn"]').textContent=`${p.by_severity?.warn||0} warnings`,document.querySelector('#sec-stats [data-key="error"]').textContent=`${p.by_severity?.error||0} errors`,document.querySelector('#sec-stats [data-key="denied"]').textContent=`${p.by_outcome?.denied||0} denied`,document.querySelector('#sec-stats [data-key="hosts"]').textContent=`${t.length} hosts`,T("sec-top-actors",p.top_actors||[]),T("sec-top-targets",p.top_targets||[])}catch(o){console.warn("[security] refreshOverview failed:",o.message)}}function T(o,u){const l=document.getElementById(o);if(!u.length){l.innerHTML='<div class="panel-empty">No data</div>';return}l.innerHTML='<table style="width:100%;font-size:0.85rem;">'+u.map(g=>`<tr><td style="padding:3px 0;word-break:break-all;">${w(String(g.key))}</td><td style="text-align:right;color:var(--muted);">${g.count}</td></tr>`).join("")+"</table>"}const z=document.getElementById("sec-filter-source"),C=document.getElementById("sec-filter-severity"),M=document.getElementById("sec-filter-host"),b=document.getElementById("sec-filter-actor"),d=document.getElementById("sec-refresh-btn");[z,C,M].forEach(o=>o.addEventListener("change",v)),b.addEventListener("input",L(v,250)),d.addEventListener("click",v);async function v(){try{const o=new URLSearchParams;o.set("limit","200"),z.value&&o.set("source_type",z.value),C.value&&o.set("severity",C.value),M.value&&o.set("source_host",M.value),b.value&&o.set("actor_prefix",b.value),A=(await(await fetch(`/api/v1/security/events?${o}`)).json()).data.events||[],S(),(!M.options.length||M.options.length===1)&&await m()}catch(o){document.getElementById("sec-events-container").innerHTML='<div class="panel-empty">Load failed: '+w(o.message)+"</div>"}}function S(){const o=document.getElementById("sec-events-container");if(!A.length){o.innerHTML='<div class="panel-empty">No events</div>';return}o.innerHTML=A.slice(0,200).map(O).join("")}function O(o){const u=o.severity||"info",l={critical:"#c0392b",error:"#e74c3c",warn:"#f39c12",notice:"#3498db",info:"#7f8c8d"}[u]||"#7f8c8d",g=o.ts?new Date(o.ts).toLocaleTimeString():"",p=o.source_type||"",t=o.actor||"\u2014",e=o.target||"",s=o.action||"",n=o.outcome||"";return`<div class="sec-event-row" style="display:grid;grid-template-columns:84px 80px 1fr 1fr 100px 90px;gap:8px;padding:5px 8px;border-bottom:1px solid var(--border);font-size:0.82rem;align-items:center;">
+      <span style="color:${l};font-weight:600;">${w(u)}</span>
+      <span style="color:var(--muted);font-size:0.75rem;">${w(p)}</span>
       <span title="${w(t)}" style="overflow:hidden;text-overflow:ellipsis;white-space:nowrap;">${w(t)}</span>
       <span title="${w(e)}" style="overflow:hidden;text-overflow:ellipsis;white-space:nowrap;">${w(s)} ${w(e)}</span>
       <span style="color:var(--muted);font-size:0.75rem;">${w(n)}</span>
-      <span style="color:var(--muted);font-size:0.75rem;text-align:right;">${w(y)}</span>
-    </div>`}async function m(){try{const p=(await(await fetch("/api/v1/security/hosts")).json()).data?.hosts||[],l=H.value;H.innerHTML='<option value="">All hosts</option>'+p.map(y=>`<option value="${w(y.id)}">${w(y.label||y.id)}</option>`).join(""),l&&(H.value=l)}catch{}}document.getElementById("sec-host-register-btn").addEventListener("click",B),document.getElementById("sec-hosts-refresh").addEventListener("click",f);async function f(){try{const p=(await(await fetch("/api/v1/security/hosts")).json()).data?.hosts||[];D=p;const l=document.getElementById("sec-hosts-container");if(!p.length){l.innerHTML='<div class="panel-empty">No hosts registered. Click \u2795 Register Host to add one.</div>';return}l.innerHTML=p.map(y=>{const u=y.enabled?y.last_seen_at?Date.now()-Date.parse(y.last_seen_at)>18e5?"\u{1F7E1} stale":"\u{1F7E2} online":"\u26AA registered":"\u{1F534} disabled";return`<div style="padding:10px 12px;border-bottom:1px solid var(--border);display:flex;justify-content:space-between;align-items:center;">
+      <span style="color:var(--muted);font-size:0.75rem;text-align:right;">${w(g)}</span>
+    </div>`}async function m(){try{const u=(await(await fetch("/api/v1/security/hosts")).json()).data?.hosts||[],l=M.value;M.innerHTML='<option value="">All hosts</option>'+u.map(g=>`<option value="${w(g.id)}">${w(g.label||g.id)}</option>`).join(""),l&&(M.value=l)}catch{}}document.getElementById("sec-host-register-btn").addEventListener("click",B),document.getElementById("sec-hosts-refresh").addEventListener("click",f);async function f(){try{const u=(await(await fetch("/api/v1/security/hosts")).json()).data?.hosts||[];D=u;const l=document.getElementById("sec-hosts-container");if(!u.length){l.innerHTML='<div class="panel-empty">No hosts registered. Click \u2795 Register Host to add one.</div>';return}l.innerHTML=u.map(g=>{const p=g.enabled?g.last_seen_at?Date.now()-Date.parse(g.last_seen_at)>18e5?"\u{1F7E1} stale":"\u{1F7E2} online":"\u26AA registered":"\u{1F534} disabled";return`<div style="padding:10px 12px;border-bottom:1px solid var(--border);display:flex;justify-content:space-between;align-items:center;">
           <div>
-            <strong>${w(y.label||y.id)}</strong>
-            <span style="color:var(--muted);margin-left:8px;font-size:0.8rem;">${w(y.type)}</span>
+            <strong>${w(g.label||g.id)}</strong>
+            <span style="color:var(--muted);margin-left:8px;font-size:0.8rem;">${w(g.type)}</span>
             <div style="color:var(--muted);font-size:0.78rem;margin-top:2px;">
-              id: ${w(y.id)} \xB7
-              registered ${new Date(y.registered_at).toLocaleDateString()} \xB7
-              last seen ${y.last_seen_at?new Date(y.last_seen_at).toLocaleString():"never"}
+              id: ${w(g.id)} \xB7
+              registered ${new Date(g.registered_at).toLocaleDateString()} \xB7
+              last seen ${g.last_seen_at?new Date(g.last_seen_at).toLocaleString():"never"}
             </div>
           </div>
           <div>
-            <span style="font-size:0.85rem;margin-right:12px;">${u}</span>
-            ${y.id==="self"?"":`<button class="btn-sm sec-host-del" data-id="${w(y.id)}" style="color:var(--bad-fg);">Remove</button>`}
+            <span style="font-size:0.85rem;margin-right:12px;">${p}</span>
+            ${g.id==="self"?"":`<button class="btn-sm sec-host-del" data-id="${w(g.id)}" style="color:var(--bad-fg);">Remove</button>`}
           </div>
-        </div>`}).join(""),l.querySelectorAll(".sec-host-del").forEach(y=>{y.addEventListener("click",async()=>{confirm(`Remove host ${y.dataset.id}? Events already received will remain in the store.`)&&(await fetch(`/api/v1/security/hosts/${encodeURIComponent(y.dataset.id)}`,{method:"DELETE"}),f())})})}catch(o){document.getElementById("sec-hosts-container").innerHTML='<div class="panel-empty">Load failed: '+w(o.message)+"</div>"}}async function B(){const o=prompt("Host id (lowercase, no spaces):");if(!o)return;const p=prompt("Display label:",o)||o,l=prompt('Type ("dashcaddy", "service", or "agent"):',"agent")||"agent";try{const y=await fetch("/api/v1/security/hosts",{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify({id:o,label:p,type:l})}),u=await y.json();if(!y.ok){alert("Failed: "+(u?.error?.message||y.statusText));return}alert(`\u2705 Host registered!
+        </div>`}).join(""),l.querySelectorAll(".sec-host-del").forEach(g=>{g.addEventListener("click",async()=>{confirm(`Remove host ${g.dataset.id}? Events already received will remain in the store.`)&&(await fetch(`/api/v1/security/hosts/${encodeURIComponent(g.dataset.id)}`,{method:"DELETE"}),f())})})}catch(o){document.getElementById("sec-hosts-container").innerHTML='<div class="panel-empty">Load failed: '+w(o.message)+"</div>"}}async function B(){const o=prompt("Host id (lowercase, no spaces):");if(!o)return;const u=prompt("Display label:",o)||o,l=prompt('Type ("dashcaddy", "service", or "agent"):',"agent")||"agent";try{const g=await fetch("/api/v1/security/hosts",{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify({id:o,label:u,type:l})}),p=await g.json();if(!g.ok){alert("Failed: "+(p?.error?.message||g.statusText));return}alert(`\u2705 Host registered!
 
-id: ${u.data.host.id}
-label: ${u.data.host.label}
-type: ${u.data.host.type}
+id: ${p.data.host.id}
+label: ${p.data.host.label}
+type: ${p.data.host.type}
 
 \u{1F511} API KEY (save this NOW \u2014 won't be shown again):
 
-${u.data.api_key}
+${p.data.api_key}
 
 Send this key as: Authorization: Bearer <api_key>
-To endpoint: POST /api/v1/security/events/ingest or /events/batch`),f()}catch(y){alert("Failed: "+y.message)}}function w(o){return String(o).replace(/[&<>"']/g,p=>({"&":"&amp;","<":"&lt;",">":"&gt;",'"':"&quot;","'":"&#39;"})[p])}function L(o,p){let l;return function(){clearTimeout(l),l=setTimeout(()=>o.apply(this,arguments),p)}}})(),window.__dc133_buildRepoOptions=function(x,E){var R=E||function(h){return String(h).replace(/[&<>"']/g,function(P){return{"&":"&amp;","<":"&lt;",">":"&gt;",'"':"&quot;","'":"&#39;"}[P]})};return'<option value="">\u2014 choose a repo \u2014</option>'+(x||[]).map(function(h){return'<option value="'+R(h.url)+'" data-id="'+R(h.id)+'">'+R(h.full_name)+(h.description?" \u2014 "+R(h.description):"")+"</option>"}).join("")},window.__dc133_requestToken=function(x,E){if(x)return"";var R=String(E||"").trim();return R||void 0},(function(){injectModal("deploys-modal",`<div id="deploys-modal" class="weather-modal">
+To endpoint: POST /api/v1/security/events/ingest or /events/batch`),f()}catch(g){alert("Failed: "+g.message)}}function w(o){return String(o).replace(/[&<>"']/g,u=>({"&":"&amp;","<":"&lt;",">":"&gt;",'"':"&quot;","'":"&#39;"})[u])}function L(o,u){let l;return function(){clearTimeout(l),l=setTimeout(()=>o.apply(this,arguments),u)}}})(),window.__dc133_buildRepoOptions=function(x,E){var j=E||function(h){return String(h).replace(/[&<>"']/g,function(P){return{"&":"&amp;","<":"&lt;",">":"&gt;",'"':"&quot;","'":"&#39;"}[P]})};return'<option value="">\u2014 choose a repo \u2014</option>'+(x||[]).map(function(h){return'<option value="'+j(h.url)+'" data-id="'+j(h.id)+'">'+j(h.full_name)+(h.description?" \u2014 "+j(h.description):"")+"</option>"}).join("")},window.__dc133_requestToken=function(x,E){if(x)return"";var j=String(E||"").trim();return j||void 0},(function(){injectModal("deploys-modal",`<div id="deploys-modal" class="weather-modal">
     <div class="weather-modal-content" style="min-width: 860px; max-width: 1200px;">
       <h3>\u{1F69A} Deploys</h3>
       <p class="modal-subtitle">
@@ -2006,16 +2006,16 @@ To endpoint: POST /api/v1/security/events/ingest or /events/batch`),f()}catch(y)
         <button class="btn" id="dep-close">Close</button>
       </div>
     </div>
-  </div>`);const x=b=>document.getElementById(b);let E=null,R=!1;function h(b){return window.escapeHtml?window.escapeHtml(String(b)):String(b).replace(/[&<>"']/g,d=>({"&":"&amp;","<":"&lt;",">":"&gt;",'"':"&quot;","'":"&#39;"})[d])}async function P(b,d){const v=await fetch("/dashcaddy-api/api/v1/deploys"+b,Object.assign({credentials:"include"},d||{}));let S=null;try{S=await v.json()}catch{S={success:!1,error:"non-JSON response"}}return{status:v.status,body:S}}function A(b){const d=x("dep-output");d.style.display="block",d.textContent=b||"(no output)",d.scrollTop=d.scrollHeight}async function D(){const b=x("dep-services"),{body:d}=await P("/services");if(!d.success){b.innerHTML="<em>"+h(d.error||"unavailable")+"</em>";return}const v=d.services||[];if(!v.length){b.innerHTML="<em>No shipdeck deployments on record yet.</em>";return}b.innerHTML='<table class="table" style="width:100%;"><thead><tr><th>Service</th><th>Last action</th><th>When</th><th>Release</th><th></th></tr></thead><tbody>'+v.map(S=>"<tr><td><strong>"+h(S.name)+"</strong></td><td>"+h(S.last_action)+"</td><td>"+h(S.last_time)+"</td><td>"+h(S.last_epoch)+'</td><td><button class="btn btn-sm dep-rollback" data-service="'+h(S.name)+'">Rollback</button> <button class="btn btn-sm dep-status" data-service="'+h(S.name)+'">Status</button></td></tr>').join("")+"</tbody></table>"}async function j(){const b=x("dep-repo-select"),{body:d}=await P("/repos");if(!d.success){b.innerHTML="<option>"+h(d.error||"unavailable")+"</option>";return}const v=d.repos||[];b.innerHTML=v.length?v.map(S=>'<option value="'+h(S.dir)+'">'+h(S.name)+"</option>").join(""):'<option value="">(no repos with a Shipdeckfile found)</option>'}async function g(b){const d=x("dep-journal"),v=b?"?service="+encodeURIComponent(b):"",{body:S}=await P("/journal"+v),O=S.rows||[];if(!O.length){d.innerHTML="<em>No journal rows.</em>";return}d.innerHTML='<table class="table" style="width:100%;"><thead><tr><th>Time</th><th>Service</th><th>Action</th><th>Release</th><th>Duration</th></tr></thead><tbody>'+O.map(m=>"<tr><td>"+h(m.time)+"</td><td>"+h(m.service)+"</td><td>"+h(m.action)+"</td><td>"+h(m.epoch)+"</td><td>"+h(m.duration||"\u2014")+"</td></tr>").join("")+"</tbody></table>"}async function $(){const b=document.getElementById("dep-gh-gitea"),d=document.getElementById("dep-gh-gitea-host"),v=document.getElementById("dep-gh-gitea-token"),S=document.getElementById("dep-gh-anonymous"),O={};if(d&&d.value.trim()&&(O.gitea_url="https://"+d.value.trim().replace(/^https?:\/*/,"")),S&&S.checked)O.token="";else{const m=window.__dc133_requestToken(!1,v&&v.value);m!==void 0&&(O.token=m)}try{const{status:m,body:f}=await P("/gitea-repos",{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify(O)});if(!f.success||!(f.repos||[]).length){b.innerHTML='<option value="">'+h(f.error||"no repos found")+"</option>";return}b.innerHTML=window.__dc133_buildRepoOptions(f.repos,h)}catch{b.innerHTML='<option value="">unavailable</option>'}}async function k(){const b=document.getElementById("dep-gh-btn"),d=document.getElementById("dep-gh-url").value.trim(),v=(document.getElementById("dep-gh-service").value.trim()||"").toLowerCase(),S=document.getElementById("dep-gh-args").value.trim();if(!d||!v){A("Repo URL and name are required.");return}const O=S?S.split(/\s+/):[];M(!0,b,"Install"),A("Installing "+d+`
+  </div>`);const x=b=>document.getElementById(b);let E=null,j=!1;function h(b){return window.escapeHtml?window.escapeHtml(String(b)):String(b).replace(/[&<>"']/g,d=>({"&":"&amp;","<":"&lt;",">":"&gt;",'"':"&quot;","'":"&#39;"})[d])}async function P(b,d){const v=await fetch("/dashcaddy-api/api/v1/deploys"+b,Object.assign({credentials:"include"},d||{}));let S=null;try{S=await v.json()}catch{S={success:!1,error:"non-JSON response"}}return{status:v.status,body:S}}function A(b){const d=x("dep-output");d.style.display="block",d.textContent=b||"(no output)",d.scrollTop=d.scrollHeight}async function D(){const b=x("dep-services"),{body:d}=await P("/services");if(!d.success){b.innerHTML="<em>"+h(d.error||"unavailable")+"</em>";return}const v=d.services||[];if(!v.length){b.innerHTML="<em>No shipdeck deployments on record yet.</em>";return}b.innerHTML='<table class="table" style="width:100%;"><thead><tr><th>Service</th><th>Last action</th><th>When</th><th>Release</th><th></th></tr></thead><tbody>'+v.map(S=>"<tr><td><strong>"+h(S.name)+"</strong></td><td>"+h(S.last_action)+"</td><td>"+h(S.last_time)+"</td><td>"+h(S.last_epoch)+'</td><td><button class="btn btn-sm dep-rollback" data-service="'+h(S.name)+'">Rollback</button> <button class="btn btn-sm dep-status" data-service="'+h(S.name)+'">Status</button></td></tr>').join("")+"</tbody></table>"}async function R(){const b=x("dep-repo-select"),{body:d}=await P("/repos");if(!d.success){b.innerHTML="<option>"+h(d.error||"unavailable")+"</option>";return}const v=d.repos||[];b.innerHTML=v.length?v.map(S=>'<option value="'+h(S.dir)+'">'+h(S.name)+"</option>").join(""):'<option value="">(no repos with a Shipdeckfile found)</option>'}async function y(b){const d=x("dep-journal"),v=b?"?service="+encodeURIComponent(b):"",{body:S}=await P("/journal"+v),O=S.rows||[];if(!O.length){d.innerHTML="<em>No journal rows.</em>";return}d.innerHTML='<table class="table" style="width:100%;"><thead><tr><th>Time</th><th>Service</th><th>Action</th><th>Release</th><th>Duration</th></tr></thead><tbody>'+O.map(m=>"<tr><td>"+h(m.time)+"</td><td>"+h(m.service)+"</td><td>"+h(m.action)+"</td><td>"+h(m.epoch)+"</td><td>"+h(m.duration||"\u2014")+"</td></tr>").join("")+"</tbody></table>"}async function $(){const b=document.getElementById("dep-gh-gitea"),d=document.getElementById("dep-gh-gitea-host"),v=document.getElementById("dep-gh-gitea-token"),S=document.getElementById("dep-gh-anonymous"),O={};if(d&&d.value.trim()&&(O.gitea_url="https://"+d.value.trim().replace(/^https?:\/*/,"")),S&&S.checked)O.token="";else{const m=window.__dc133_requestToken(!1,v&&v.value);m!==void 0&&(O.token=m)}try{const{status:m,body:f}=await P("/gitea-repos",{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify(O)});if(!f.success||!(f.repos||[]).length){b.innerHTML='<option value="">'+h(f.error||"no repos found")+"</option>";return}b.innerHTML=window.__dc133_buildRepoOptions(f.repos,h)}catch{b.innerHTML='<option value="">unavailable</option>'}}async function k(){const b=document.getElementById("dep-gh-btn"),d=document.getElementById("dep-gh-url").value.trim(),v=(document.getElementById("dep-gh-service").value.trim()||"").toLowerCase(),S=document.getElementById("dep-gh-args").value.trim();if(!d||!v){A("Repo URL and name are required.");return}const O=S?S.split(/\s+/):[];H(!0,b,"Install"),A("Installing "+d+`
 Cloning, building, gating and DNS-ing... (~30-60s)`);try{const m=!!(document.getElementById("dep-gh-anonymous")||{}).checked,f=(document.getElementById("dep-gh-gitea-token")||{value:""}).value,B=window.__dc133_requestToken(m,f),{status:w,body:L}=await P("/install",{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify({repo_url:d,service:v,args:O,token:B})});if(!L.success){A((L.output?L.output+`
-`:"")+"FAIL "+(L.error||"HTTP "+w)),M(!1,b,"Install");return}const o=L.service||{};if(!(window.APPS||[]).some(l=>l.id===o.id)){const l={id:o.id,name:o.name||o.id,url:o.url,logo:o.logo,tailscaleOnly:!0,isCustom:!0};try{await fetch("/dashcaddy-api/api/v1/services",{method:"POST",credentials:"include",headers:{"Content-Type":"application/json"},body:JSON.stringify(l)}),window.APPS.push(l),typeof window.renderApps=="function"&&window.renderApps(),typeof window.renderGrid=="function"&&window.renderGrid()}catch{}}A("INSTALLED "+(o.name||o.id)+" in "+(o.deploy_seconds||"?")+`s
+`:"")+"FAIL "+(L.error||"HTTP "+w)),H(!1,b,"Install");return}const o=L.service||{};if(!(window.APPS||[]).some(l=>l.id===o.id)){const l={id:o.id,name:o.name||o.id,url:o.url,logo:o.logo,tailscaleOnly:!0,isCustom:!0};try{await fetch("/dashcaddy-api/api/v1/services",{method:"POST",credentials:"include",headers:{"Content-Type":"application/json"},body:JSON.stringify(l)}),window.APPS.push(l),typeof window.renderApps=="function"&&window.renderApps(),typeof window.renderGrid=="function"&&window.renderGrid()}catch{}}A("INSTALLED "+(o.name||o.id)+" in "+(o.deploy_seconds||"?")+`s
 Card: `+(o.url||"")+`
-`+(L.output||"").slice(-800)),D()}catch(m){A("install error: "+m.message)}M(!1,b,"Install")}function M(b,d,v){d&&(d.disabled=b,v&&(d.textContent=b?"Working\u2026":v))}async function T(){const b=x("dep-deploy-btn"),d=x("dep-repo-select").value;if(d){M(!0,b,"Deploy"),A("Deploying "+d+`
+`+(L.output||"").slice(-800)),D()}catch(m){A("install error: "+m.message)}H(!1,b,"Install")}function H(b,d,v){d&&(d.disabled=b,v&&(d.textContent=b?"Working\u2026":v))}async function T(){const b=x("dep-deploy-btn"),d=x("dep-repo-select").value;if(d){H(!0,b,"Deploy"),A("Deploying "+d+`
 This can take ~30-60s\u2026`);try{const{body:v}=await P("/deploy",{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify({dir:d})});A((v.output||v.error||"")+(v.success?`
 \u2705 SUCCESS`:`
-\u274C FAILED`)),D()}catch(v){A("deploy error: "+v.message)}M(!1,b,"Deploy")}}async function z(b,d){if(confirm("Roll back "+b+" to the previous release?")){M(!0,d,"Rollback"),A("Rolling back "+b+"\u2026");try{const{body:v}=await P("/rollback",{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify({service:b})});A((v.output||v.error||"")+(v.success?`
+\u274C FAILED`)),D()}catch(v){A("deploy error: "+v.message)}H(!1,b,"Deploy")}}async function z(b,d){if(confirm("Roll back "+b+" to the previous release?")){H(!0,d,"Rollback"),A("Rolling back "+b+"\u2026");try{const{body:v}=await P("/rollback",{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify({service:b})});A((v.output||v.error||"")+(v.success?`
 \u2705 ROLLED BACK`:`
-\u274C FAILED`)),D()}catch(v){A("rollback error: "+v.message)}M(!1,d,"Rollback")}}async function C(b,d){M(!0,d,"Status");try{const{body:v}=await P("/status?service="+encodeURIComponent(b));A(v.output||v.error||"(no output)")}catch(v){A("status error: "+v.message)}M(!1,d,"Status")}function H(){E=document.getElementById("deploys-btn"),E&&(E.addEventListener("click",async()=>{x("deploys-modal").classList.add("open"),R||(R=!0,D(),j(),g(""),$())}),x("dep-close").addEventListener("click",()=>{x("deploys-modal").classList.remove("open")}),document.querySelectorAll(".dep-tab").forEach(b=>{b.addEventListener("click",()=>{document.querySelectorAll(".dep-tab").forEach(d=>d.classList.remove("active")),b.classList.add("active"),document.querySelectorAll("#deploys-modal .dep-panel").forEach(d=>{d.style.display=d.dataset.panel===b.dataset.tab?"block":"none"})})}),x("dep-deploy-btn").addEventListener("click",T),x("dep-gh-btn").addEventListener("click",k),["dep-gh-gitea-host","dep-gh-gitea-token"].forEach(b=>{const d=document.getElementById(b);d&&d.addEventListener("change",()=>$())}),document.getElementById("dep-gh-gitea").addEventListener("change",b=>{const d=b.target.value;if(d){document.getElementById("dep-gh-url").value=d;const v=b.target.selectedOptions[0],S=v&&v.dataset?v.dataset.id:"",O=document.getElementById("dep-gh-service");S&&!O.value&&(O.value=S)}}),x("dep-journal-btn").addEventListener("click",()=>g(x("dep-journal-name").value.trim())),x("dep-status-btn").addEventListener("click",()=>{const b=x("dep-status-name").value.trim();b&&C(b)}),x("dep-services").addEventListener("click",b=>{const d=b.target.closest(".dep-rollback");if(d)return z(d.dataset.service,d);const v=b.target.closest(".dep-status");if(v)return C(v.dataset.service,v)}))}document.readyState==="loading"?document.addEventListener("DOMContentLoaded",H):H()})(),(function(){const x=new ErrorHandler;injectModal("weather-modal",`<div id="weather-modal" class="weather-modal"><div class="weather-modal-content"><h3>Weather Settings</h3>
+\u274C FAILED`)),D()}catch(v){A("rollback error: "+v.message)}H(!1,d,"Rollback")}}async function C(b,d){H(!0,d,"Status");try{const{body:v}=await P("/status?service="+encodeURIComponent(b));A(v.output||v.error||"(no output)")}catch(v){A("status error: "+v.message)}H(!1,d,"Status")}function M(){E=document.getElementById("deploys-btn"),E&&(E.addEventListener("click",async()=>{x("deploys-modal").classList.add("open"),j||(j=!0,D(),R(),y(""),$())}),x("dep-close").addEventListener("click",()=>{x("deploys-modal").classList.remove("open")}),document.querySelectorAll(".dep-tab").forEach(b=>{b.addEventListener("click",()=>{document.querySelectorAll(".dep-tab").forEach(d=>d.classList.remove("active")),b.classList.add("active"),document.querySelectorAll("#deploys-modal .dep-panel").forEach(d=>{d.style.display=d.dataset.panel===b.dataset.tab?"block":"none"})})}),x("dep-deploy-btn").addEventListener("click",T),x("dep-gh-btn").addEventListener("click",k),["dep-gh-gitea-host","dep-gh-gitea-token"].forEach(b=>{const d=document.getElementById(b);d&&d.addEventListener("change",()=>$())}),document.getElementById("dep-gh-gitea").addEventListener("change",b=>{const d=b.target.value;if(d){document.getElementById("dep-gh-url").value=d;const v=b.target.selectedOptions[0],S=v&&v.dataset?v.dataset.id:"",O=document.getElementById("dep-gh-service");S&&!O.value&&(O.value=S)}}),x("dep-journal-btn").addEventListener("click",()=>y(x("dep-journal-name").value.trim())),x("dep-status-btn").addEventListener("click",()=>{const b=x("dep-status-name").value.trim();b&&C(b)}),x("dep-services").addEventListener("click",b=>{const d=b.target.closest(".dep-rollback");if(d)return z(d.dataset.service,d);const v=b.target.closest(".dep-status");if(v)return C(v.dataset.service,v)}))}document.readyState==="loading"?document.addEventListener("DOMContentLoaded",M):M()})(),(function(){const x=new ErrorHandler;injectModal("weather-modal",`<div id="weather-modal" class="weather-modal"><div class="weather-modal-content"><h3>Weather Settings</h3>
     <label for="weather-location-input">Location:</label>
     <input type="text" id="weather-location-input" placeholder="City name or ZIP (e.g., Hamburg, 90210)" maxlength="100">
     <div style="font-size: 0.78rem; color: var(--muted); margin-top: 4px;">Enter a city name, postal code, or &ldquo;City, Country&rdquo;</div>
@@ -2026,7 +2026,7 @@ This can take ~30-60s\u2026`);try{const{body:v}=await P("/deploy",{method:"POST"
         <label class="weather-unit-option"><input type="radio" name="weather-unit-radio" value="metric"><span class="weather-unit-card">&deg;C / km/h</span></label>
       </div>
     </div>
-    <div class="weather-modal-buttons"><button id="weather-cancel">Cancel</button><button id="weather-save">Save</button></div></div></div>`);const E="weather-location",R="weather-zip",h="weather-geo",P="weather-unit";!safeGet(E)&&safeGet(R)&&safeSet(E,safeGet(R));function A(){return safeGet(P)||"imperial"}function D(){return{icon:document.querySelector(".weather-icon"),temp:document.querySelector(".weather-temp"),condition:document.querySelector(".weather-condition"),location:document.querySelector(".weather-location"),wind:document.querySelector(".weather-wind")}}const j={0:"Clear sky",1:"Mainly clear",2:"Partly cloudy",3:"Overcast",45:"Fog",48:"Rime fog",51:"Light drizzle",53:"Drizzle",55:"Dense drizzle",56:"Freezing drizzle",57:"Dense freezing drizzle",61:"Light rain",63:"Moderate rain",65:"Heavy rain",66:"Light freezing rain",67:"Heavy freezing rain",71:"Light snow",73:"Moderate snow",75:"Heavy snow",77:"Snow grains",80:"Light showers",81:"Moderate showers",82:"Violent showers",85:"Light snow showers",86:"Heavy snow showers",95:"Thunderstorm",96:"Thunderstorm with hail",99:"Severe thunderstorm"},g={0:"\u2600\uFE0F",1:"\u{1F324}\uFE0F",2:"\u26C5",3:"\u2601\uFE0F",45:"\u{1F32B}\uFE0F",48:"\u{1F32B}\uFE0F",51:"\u{1F326}\uFE0F",53:"\u{1F326}\uFE0F",55:"\u{1F326}\uFE0F",56:"\u{1F328}\uFE0F",57:"\u{1F328}\uFE0F",61:"\u{1F326}\uFE0F",63:"\u{1F327}\uFE0F",65:"\u{1F327}\uFE0F",66:"\u{1F328}\uFE0F",67:"\u{1F328}\uFE0F",71:"\u{1F328}\uFE0F",73:"\u2744\uFE0F",75:"\u2744\uFE0F",77:"\u2744\uFE0F",80:"\u{1F326}\uFE0F",81:"\u{1F327}\uFE0F",82:"\u{1F327}\uFE0F",85:"\u{1F328}\uFE0F",86:"\u2744\uFE0F",95:"\u26C8\uFE0F",96:"\u26C8\uFE0F",99:"\u26C8\uFE0F"},$=["N","NNE","NE","ENE","E","ESE","SE","SSE","S","SSW","SW","WSW","W","WNW","NW","NNW"];function k(d){return $[Math.round(d/22.5)%16]}async function M(d){const v=safeGet(h);if(v)try{const B=JSON.parse(v);if(B.query===d)return B}catch{}const S=await fetch(`https://geocoding-api.open-meteo.com/v1/search?name=${encodeURIComponent(d)}&count=1&language=en&format=json`);if(!S.ok)throw new Error("Geocoding failed");const O=await S.json();if(!O.results||!O.results.length)throw new Error("Location not found");const m=O.results[0],f={query:d,lat:m.latitude,lon:m.longitude,city:m.name,state:m.admin1||"",country:m.country||"",countryCode:m.country_code||""};return safeSet(h,JSON.stringify(f)),f}function T(d){return d.countryCode==="US"&&d.state?`${d.city}, ${d.state}`:d.country?`${d.city}, ${d.country}`:d.city}async function z(d){try{const v=await M(d),S=A(),O=S==="metric"?"celsius":"fahrenheit",m=S==="metric"?"kmh":"mph",f=`https://api.open-meteo.com/v1/forecast?latitude=${v.lat}&longitude=${v.lon}&current=temperature_2m,weather_code,wind_speed_10m,wind_direction_10m&temperature_unit=${O}&wind_speed_unit=${m}`,B=await fetch(f);if(!B.ok)throw new Error("Weather fetch failed");const L=(await B.json()).current,o=L.weather_code;return{temp:Math.round(L.temperature_2m),condition:j[o]||"Unknown",icon:g[o]||"\u{1F324}\uFE0F",locationStr:T(v),windSpeed:Math.round(L.wind_speed_10m),windDir:k(L.wind_direction_10m),unit:S}}catch(v){return console.warn("Weather fetch failed:",v),null}}async function C(){const d=D();if(!d.icon||!d.temp||!d.condition||!d.location||!d.wind){console.warn("Weather widget elements not found");return}const v=safeGet(E);if(!v){d.location.textContent="Set Location",d.temp.textContent="--\xB0",d.condition.textContent="Click \u2699\uFE0F to configure",d.wind.textContent="--",d.icon.innerHTML='<span class="weather-emoji">\u{1F324}\uFE0F</span>';return}try{const S=await z(v);if(S){const O=S.unit==="metric"?"\xB0C":"\xB0F",m=S.unit==="metric"?"km/h":"mph";d.location.textContent=S.locationStr,d.temp.textContent=`${S.temp}${O}`,d.condition.textContent=S.condition,d.wind.textContent=`Wind: ${S.windSpeed} ${m} ${S.windDir}`,d.icon.innerHTML=`<span class="weather-emoji">${escapeHtml(S.icon)}</span>`}}catch(S){x.logError("[Weather] Update Error",S,{function:"updateWeather"}),d.location.textContent="Weather Error",d.temp.textContent="Error",d.condition.textContent="Failed to load",d.wind.textContent="--"}}const H=document.getElementById("weather-modal"),b=document.getElementById("weather-location-input");document.getElementById("weather-settings")?.addEventListener("click",()=>{b.value=safeGet(E)||"";const d=A(),v=H.querySelector(`input[name="weather-unit-radio"][value="${d}"]`);v&&(v.checked=!0),H.classList.add("show"),b.focus()}),document.getElementById("weather-cancel")?.addEventListener("click",()=>{H.classList.remove("show")}),document.getElementById("weather-save")?.addEventListener("click",()=>{const d=b.value.trim();if(d){safeGet(E)!==d&&safeSet(h,""),safeSet(E,d);const S=H.querySelector('input[name="weather-unit-radio"]:checked'),O=S?S.value:"imperial",m=A();safeSet(P,O),m!==O&&safeSet(h,""),H.classList.remove("show"),C()}else showNotification("Please enter a location (e.g., Hamburg, London, 90210)","warning")}),wireModal(H),document.addEventListener("keydown",d=>{d.key==="Escape"&&H.classList.contains("show")&&H.classList.remove("show")}),C(),setInterval(C,DC.POLL.WEATHER)})(),(function(){const x=document.getElementById("clock-widget"),E=document.getElementById("clock-render");if(!x||!E)return;const R=["Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"],h=["January","February","March","April","May","June","July","August","September","October","November","December"],P=["XII","I","II","III","IV","V","VI","VII","VIII","IX","X","XI"];let A=safeGet("clock-style")||"default",D=-1,j=!1,g="",$="",k=null,M=null;function T(t){if(j||safeGet("clock-chimes")!=="true")return;j=!0;const e=parseInt(safeGet("clock-chime-volume")||"50",10)/100;let s=0;function n(){if(s>=t){j=!1;return}const r=new Audio("/assets/sounds/church-bell.mp3");r.volume=e,r.play().catch(()=>{}),s++,s<t?setTimeout(n,2500):setTimeout(()=>{j=!1},2500)}n()}function z(t){return R[t.getDay()]+", "+h[t.getMonth()]+" "+t.getDate()+", "+t.getFullYear()}function C(){$="",k=null}function H(){return $!=="digital"&&(E.innerHTML='<div class="clock-time"><span class="clock-main"></span><span class="clock-seconds"></span><span class="clock-ampm"></span></div><div class="clock-date"></div>',k={main:E.querySelector(".clock-main"),seconds:E.querySelector(".clock-seconds"),ampm:E.querySelector(".clock-ampm"),date:E.querySelector(".clock-date")},$="digital"),k}function b(t){const e=t.getHours(),s=t.getMinutes(),n=t.getSeconds(),r=e>=12?"PM":"AM",a=e%12||12,i=H();i.main.textContent=`${a}:${String(s).padStart(2,"0")}`,i.seconds.textContent=`:${String(n).padStart(2,"0")}`,i.ampm.textContent=r,i.date.textContent=z(t)}function d(t,e){const s=t.getHours(),n=t.getMinutes(),r=t.getSeconds(),a=s>=12?"PM":"AM",i=s%12||12,c=H();c.main.textContent=`${String(i).padStart(2,"0")}:${String(n).padStart(2,"0")}`,c.seconds.textContent=`:${String(r).padStart(2,"0")}`,c.ampm.textContent=a,c.date.textContent=z(t)}function v(t){const e=t.getHours(),s=t.getMinutes(),n=t.getSeconds(),r=e>=12?"PM":"AM",a=e%12||12,i=String(a).padStart(2," ")+String(s).padStart(2,"0")+String(n).padStart(2,"0");let c='<div class="flip-clock-row">';if(c+=S(i[0],0),c+=S(i[1],1),c+='<span class="flip-colon">:</span>',c+=S(i[2],2),c+=S(i[3],3),c+='<span class="flip-colon">:</span>',c+=S(i[4],4),c+=S(i[5],5),c+=`<span class="flip-ampm">${r}</span>`,c+="</div>",c+=`<div class="clock-date">${z(t)}</div>`,E.innerHTML=c,$="flip",g){for(let I=0;I<6;I++)if(i[I]!==g[I]){const N=E.querySelector(`.flip-card[data-idx="${I}"]`);N&&N.classList.add("flipping")}}g=i}function S(t,e){const s=t===" "?"":t;return`<div class="flip-card" data-idx="${e}"><div class="flip-top">${s}</div><div class="flip-bottom">${s}</div></div>`}function O(t){const e=t.getHours(),s=t.getMinutes(),n=t.getSeconds(),r=e%12||12,a=e>=12?"PM":"AM",i=[Math.floor(r/10),r%10,Math.floor(s/10),s%10,Math.floor(n/10),n%10];let c='<div class="binary-clock">';c+='<div class="binary-labels"><span>H</span><span>H</span><span>M</span><span>M</span><span>S</span><span>S</span></div>';for(let I=3;I>=0;I--){c+='<div class="binary-row">';for(let N=0;N<6;N++){const U=i[N]>>I&1;c+=`<div class="binary-dot ${U?"on":""}"></div>`}c+="</div>"}c+='<div class="binary-values">';for(let I=0;I<6;I++)c+=`<span>${i[I]}</span>`;c+="</div>",c+=`<div class="binary-ampm">${a}</div>`,c+="</div>",c+=`<div class="clock-date">${z(t)}</div>`,E.innerHTML=c,$="binary"}function m(t,e){const s=t.getHours(),n=t.getMinutes(),r=t.getSeconds(),a=120,i=a/2,c=a/2,I=r/60*360-90,N=(n+r/60)/60*360-90,U=(s%12+n/60)/12*360-90;let _="";for(let X=1;X<=12;X++){const Q=X/12*2*Math.PI-Math.PI/2,ne=47,oe=i+ne*Math.cos(Q),se=c+ne*Math.sin(Q),Y=e?P[X%12]:X;_+=`<text x="${oe}" y="${se}" text-anchor="middle" dominant-baseline="central" fill="var(--fg)" font-size="${e?"7":"9"}" font-weight="600" font-family="'Sami Grotesk',sans-serif">${Y}</text>`}let F="";for(let X=0;X<60;X++){const Q=X/60*2*Math.PI-Math.PI/2,ne=56,oe=X%5===0?52:54,se=i+oe*Math.cos(Q),Y=c+oe*Math.sin(Q),ie=i+ne*Math.cos(Q),re=c+ne*Math.sin(Q),ae=X%5===0?1.5:.5;F+=`<line x1="${se}" y1="${Y}" x2="${ie}" y2="${re}" stroke="var(--muted)" stroke-width="${ae}" stroke-linecap="round"/>`}const q=`<svg class="analog-clock-svg" viewBox="0 0 ${a} ${a}" width="${a}" height="${a}">
+    <div class="weather-modal-buttons"><button id="weather-cancel">Cancel</button><button id="weather-save">Save</button></div></div></div>`);const E="weather-location",j="weather-zip",h="weather-geo",P="weather-unit";!safeGet(E)&&safeGet(j)&&safeSet(E,safeGet(j));function A(){return safeGet(P)||"imperial"}function D(){return{icon:document.querySelector(".weather-icon"),temp:document.querySelector(".weather-temp"),condition:document.querySelector(".weather-condition"),location:document.querySelector(".weather-location"),wind:document.querySelector(".weather-wind")}}const R={0:"Clear sky",1:"Mainly clear",2:"Partly cloudy",3:"Overcast",45:"Fog",48:"Rime fog",51:"Light drizzle",53:"Drizzle",55:"Dense drizzle",56:"Freezing drizzle",57:"Dense freezing drizzle",61:"Light rain",63:"Moderate rain",65:"Heavy rain",66:"Light freezing rain",67:"Heavy freezing rain",71:"Light snow",73:"Moderate snow",75:"Heavy snow",77:"Snow grains",80:"Light showers",81:"Moderate showers",82:"Violent showers",85:"Light snow showers",86:"Heavy snow showers",95:"Thunderstorm",96:"Thunderstorm with hail",99:"Severe thunderstorm"},y={0:"\u2600\uFE0F",1:"\u{1F324}\uFE0F",2:"\u26C5",3:"\u2601\uFE0F",45:"\u{1F32B}\uFE0F",48:"\u{1F32B}\uFE0F",51:"\u{1F326}\uFE0F",53:"\u{1F326}\uFE0F",55:"\u{1F326}\uFE0F",56:"\u{1F328}\uFE0F",57:"\u{1F328}\uFE0F",61:"\u{1F326}\uFE0F",63:"\u{1F327}\uFE0F",65:"\u{1F327}\uFE0F",66:"\u{1F328}\uFE0F",67:"\u{1F328}\uFE0F",71:"\u{1F328}\uFE0F",73:"\u2744\uFE0F",75:"\u2744\uFE0F",77:"\u2744\uFE0F",80:"\u{1F326}\uFE0F",81:"\u{1F327}\uFE0F",82:"\u{1F327}\uFE0F",85:"\u{1F328}\uFE0F",86:"\u2744\uFE0F",95:"\u26C8\uFE0F",96:"\u26C8\uFE0F",99:"\u26C8\uFE0F"},$=["N","NNE","NE","ENE","E","ESE","SE","SSE","S","SSW","SW","WSW","W","WNW","NW","NNW"];function k(d){return $[Math.round(d/22.5)%16]}async function H(d){const v=safeGet(h);if(v)try{const B=JSON.parse(v);if(B.query===d)return B}catch{}const S=await fetch(`https://geocoding-api.open-meteo.com/v1/search?name=${encodeURIComponent(d)}&count=1&language=en&format=json`);if(!S.ok)throw new Error("Geocoding failed");const O=await S.json();if(!O.results||!O.results.length)throw new Error("Location not found");const m=O.results[0],f={query:d,lat:m.latitude,lon:m.longitude,city:m.name,state:m.admin1||"",country:m.country||"",countryCode:m.country_code||""};return safeSet(h,JSON.stringify(f)),f}function T(d){return d.countryCode==="US"&&d.state?`${d.city}, ${d.state}`:d.country?`${d.city}, ${d.country}`:d.city}async function z(d){try{const v=await H(d),S=A(),O=S==="metric"?"celsius":"fahrenheit",m=S==="metric"?"kmh":"mph",f=`https://api.open-meteo.com/v1/forecast?latitude=${v.lat}&longitude=${v.lon}&current=temperature_2m,weather_code,wind_speed_10m,wind_direction_10m&temperature_unit=${O}&wind_speed_unit=${m}`,B=await fetch(f);if(!B.ok)throw new Error("Weather fetch failed");const L=(await B.json()).current,o=L.weather_code;return{temp:Math.round(L.temperature_2m),condition:R[o]||"Unknown",icon:y[o]||"\u{1F324}\uFE0F",locationStr:T(v),windSpeed:Math.round(L.wind_speed_10m),windDir:k(L.wind_direction_10m),unit:S}}catch(v){return console.warn("Weather fetch failed:",v),null}}async function C(){const d=D();if(!d.icon||!d.temp||!d.condition||!d.location||!d.wind){console.warn("Weather widget elements not found");return}const v=safeGet(E);if(!v){d.location.textContent="Set Location",d.temp.textContent="--\xB0",d.condition.textContent="Click \u2699\uFE0F to configure",d.wind.textContent="--",d.icon.innerHTML='<span class="weather-emoji">\u{1F324}\uFE0F</span>';return}try{const S=await z(v);if(S){const O=S.unit==="metric"?"\xB0C":"\xB0F",m=S.unit==="metric"?"km/h":"mph";d.location.textContent=S.locationStr,d.temp.textContent=`${S.temp}${O}`,d.condition.textContent=S.condition,d.wind.textContent=`Wind: ${S.windSpeed} ${m} ${S.windDir}`,d.icon.innerHTML=`<span class="weather-emoji">${escapeHtml(S.icon)}</span>`}}catch(S){x.logError("[Weather] Update Error",S,{function:"updateWeather"}),d.location.textContent="Weather Error",d.temp.textContent="Error",d.condition.textContent="Failed to load",d.wind.textContent="--"}}const M=document.getElementById("weather-modal"),b=document.getElementById("weather-location-input");document.getElementById("weather-settings")?.addEventListener("click",()=>{b.value=safeGet(E)||"";const d=A(),v=M.querySelector(`input[name="weather-unit-radio"][value="${d}"]`);v&&(v.checked=!0),M.classList.add("show"),b.focus()}),document.getElementById("weather-cancel")?.addEventListener("click",()=>{M.classList.remove("show")}),document.getElementById("weather-save")?.addEventListener("click",()=>{const d=b.value.trim();if(d){safeGet(E)!==d&&safeSet(h,""),safeSet(E,d);const S=M.querySelector('input[name="weather-unit-radio"]:checked'),O=S?S.value:"imperial",m=A();safeSet(P,O),m!==O&&safeSet(h,""),M.classList.remove("show"),C()}else showNotification("Please enter a location (e.g., Hamburg, London, 90210)","warning")}),wireModal(M),document.addEventListener("keydown",d=>{d.key==="Escape"&&M.classList.contains("show")&&M.classList.remove("show")}),C(),setInterval(C,DC.POLL.WEATHER)})(),(function(){const x=document.getElementById("clock-widget"),E=document.getElementById("clock-render");if(!x||!E)return;const j=["Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"],h=["January","February","March","April","May","June","July","August","September","October","November","December"],P=["XII","I","II","III","IV","V","VI","VII","VIII","IX","X","XI"];let A=safeGet("clock-style")||"default",D=-1,R=!1,y="",$="",k=null,H=null;function T(t){if(R||safeGet("clock-chimes")!=="true")return;R=!0;const e=parseInt(safeGet("clock-chime-volume")||"50",10)/100;let s=0;function n(){if(s>=t){R=!1;return}const r=new Audio("/assets/sounds/church-bell.mp3");r.volume=e,r.play().catch(()=>{}),s++,s<t?setTimeout(n,2500):setTimeout(()=>{R=!1},2500)}n()}function z(t){return j[t.getDay()]+", "+h[t.getMonth()]+" "+t.getDate()+", "+t.getFullYear()}function C(){$="",k=null}function M(){return $!=="digital"&&(E.innerHTML='<div class="clock-time"><span class="clock-main"></span><span class="clock-seconds"></span><span class="clock-ampm"></span></div><div class="clock-date"></div>',k={main:E.querySelector(".clock-main"),seconds:E.querySelector(".clock-seconds"),ampm:E.querySelector(".clock-ampm"),date:E.querySelector(".clock-date")},$="digital"),k}function b(t){const e=t.getHours(),s=t.getMinutes(),n=t.getSeconds(),r=e>=12?"PM":"AM",a=e%12||12,i=M();i.main.textContent=`${a}:${String(s).padStart(2,"0")}`,i.seconds.textContent=`:${String(n).padStart(2,"0")}`,i.ampm.textContent=r,i.date.textContent=z(t)}function d(t,e){const s=t.getHours(),n=t.getMinutes(),r=t.getSeconds(),a=s>=12?"PM":"AM",i=s%12||12,c=M();c.main.textContent=`${String(i).padStart(2,"0")}:${String(n).padStart(2,"0")}`,c.seconds.textContent=`:${String(r).padStart(2,"0")}`,c.ampm.textContent=a,c.date.textContent=z(t)}function v(t){const e=t.getHours(),s=t.getMinutes(),n=t.getSeconds(),r=e>=12?"PM":"AM",a=e%12||12,i=String(a).padStart(2," ")+String(s).padStart(2,"0")+String(n).padStart(2,"0");let c='<div class="flip-clock-row">';if(c+=S(i[0],0),c+=S(i[1],1),c+='<span class="flip-colon">:</span>',c+=S(i[2],2),c+=S(i[3],3),c+='<span class="flip-colon">:</span>',c+=S(i[4],4),c+=S(i[5],5),c+=`<span class="flip-ampm">${r}</span>`,c+="</div>",c+=`<div class="clock-date">${z(t)}</div>`,E.innerHTML=c,$="flip",y){for(let I=0;I<6;I++)if(i[I]!==y[I]){const N=E.querySelector(`.flip-card[data-idx="${I}"]`);N&&N.classList.add("flipping")}}y=i}function S(t,e){const s=t===" "?"":t;return`<div class="flip-card" data-idx="${e}"><div class="flip-top">${s}</div><div class="flip-bottom">${s}</div></div>`}function O(t){const e=t.getHours(),s=t.getMinutes(),n=t.getSeconds(),r=e%12||12,a=e>=12?"PM":"AM",i=[Math.floor(r/10),r%10,Math.floor(s/10),s%10,Math.floor(n/10),n%10];let c='<div class="binary-clock">';c+='<div class="binary-labels"><span>H</span><span>H</span><span>M</span><span>M</span><span>S</span><span>S</span></div>';for(let I=3;I>=0;I--){c+='<div class="binary-row">';for(let N=0;N<6;N++){const U=i[N]>>I&1;c+=`<div class="binary-dot ${U?"on":""}"></div>`}c+="</div>"}c+='<div class="binary-values">';for(let I=0;I<6;I++)c+=`<span>${i[I]}</span>`;c+="</div>",c+=`<div class="binary-ampm">${a}</div>`,c+="</div>",c+=`<div class="clock-date">${z(t)}</div>`,E.innerHTML=c,$="binary"}function m(t,e){const s=t.getHours(),n=t.getMinutes(),r=t.getSeconds(),a=120,i=a/2,c=a/2,I=r/60*360-90,N=(n+r/60)/60*360-90,U=(s%12+n/60)/12*360-90;let _="";for(let X=1;X<=12;X++){const Q=X/12*2*Math.PI-Math.PI/2,ne=47,oe=i+ne*Math.cos(Q),se=c+ne*Math.sin(Q),Y=e?P[X%12]:X;_+=`<text x="${oe}" y="${se}" text-anchor="middle" dominant-baseline="central" fill="var(--fg)" font-size="${e?"7":"9"}" font-weight="600" font-family="'Sami Grotesk',sans-serif">${Y}</text>`}let F="";for(let X=0;X<60;X++){const Q=X/60*2*Math.PI-Math.PI/2,ne=56,oe=X%5===0?52:54,se=i+oe*Math.cos(Q),Y=c+oe*Math.sin(Q),ie=i+ne*Math.cos(Q),re=c+ne*Math.sin(Q),ae=X%5===0?1.5:.5;F+=`<line x1="${se}" y1="${Y}" x2="${ie}" y2="${re}" stroke="var(--muted)" stroke-width="${ae}" stroke-linecap="round"/>`}const q=`<svg class="analog-clock-svg" viewBox="0 0 ${a} ${a}" width="${a}" height="${a}">
       <circle cx="${i}" cy="${c}" r="58" fill="none" stroke="var(--border)" stroke-width="2"/>
       ${F}
       ${_}
@@ -2034,7 +2034,7 @@ This can take ~30-60s\u2026`);try{const{body:v}=await P("/deploy",{method:"POST"
       <line x1="${i}" y1="${c}" x2="${i+38*Math.cos(N*Math.PI/180)}" y2="${c+38*Math.sin(N*Math.PI/180)}" stroke="var(--fg)" stroke-width="2" stroke-linecap="round"/>
       <line x1="${i}" y1="${c}" x2="${i+42*Math.cos(I*Math.PI/180)}" y2="${c+42*Math.sin(I*Math.PI/180)}" stroke="#e74c3c" stroke-width="1" stroke-linecap="round"/>
       <circle cx="${i}" cy="${c}" r="3" fill="var(--fg)"/>
-    </svg>`,J=t.getHours()>=12?"PM":"AM";E.innerHTML=`<div class="analog-clock-wrap">${q}<div class="analog-info"><span class="analog-digital">${t.getHours()%12||12}:${String(n).padStart(2,"0")} ${J}</span><span class="analog-date-sm">${z(t)}</span></div></div>`,$="analog"}function f(){const t=new Date,e=t.getHours()%12||12,s=t.getMinutes(),n=t.getSeconds(),r="clock-widget"+(A!=="default"?" "+A:"");switch(x.className!==r&&(x.className=r),A){case"lcd":d(t);break;case"lcd-blue":d(t);break;case"lcd-amber":d(t);break;case"lcd-retro":d(t);break;case"lcd-taxi":d(t);break;case"flip":v(t);break;case"binary":O(t);break;case"analog":m(t,!1);break;case"roman":m(t,!0);break;default:b(t)}s===0&&n===0&&e!==D&&(D=e,T(e)),s!==0&&(D=-1)}function B(){clearTimeout(M);const t=document.hidden?6e4:1e3,e=t-Date.now()%t+25;M=setTimeout(()=>{f(),B()},e)}document.addEventListener("visibilitychange",()=>{g="",C(),f(),B()}),f(),B();const w=[{id:"default",label:"Default",icon:"\u{1F550}"},{id:"lcd",label:"LCD Green",icon:"\u{1F49A}"},{id:"lcd-blue",label:"LCD Blue",icon:"\u{1F499}"},{id:"lcd-amber",label:"LCD Amber",icon:"\u{1F7E0}"},{id:"lcd-retro",label:"LCD Retro",icon:"\u{1F7E9}"},{id:"lcd-taxi",label:"LCD Taxi",icon:"\u{1F7E1}"},{id:"flip",label:"Flip Clock",icon:"\u{1F4DF}"},{id:"binary",label:"Binary",icon:"\u{1F4BB}"},{id:"analog",label:"Analog",icon:"\u23F0"},{id:"roman",label:"Roman",icon:"\u{1F3DB}\uFE0F"}];let L='<div class="clock-style-grid">';w.forEach(t=>{L+=`<label class="clock-style-option">
+    </svg>`,J=t.getHours()>=12?"PM":"AM";E.innerHTML=`<div class="analog-clock-wrap">${q}<div class="analog-info"><span class="analog-digital">${t.getHours()%12||12}:${String(n).padStart(2,"0")} ${J}</span><span class="analog-date-sm">${z(t)}</span></div></div>`,$="analog"}function f(){const t=new Date,e=t.getHours()%12||12,s=t.getMinutes(),n=t.getSeconds(),r="clock-widget"+(A!=="default"?" "+A:"");switch(x.className!==r&&(x.className=r),A){case"lcd":d(t);break;case"lcd-blue":d(t);break;case"lcd-amber":d(t);break;case"lcd-retro":d(t);break;case"lcd-taxi":d(t);break;case"flip":v(t);break;case"binary":O(t);break;case"analog":m(t,!1);break;case"roman":m(t,!0);break;default:b(t)}s===0&&n===0&&e!==D&&(D=e,T(e)),s!==0&&(D=-1)}function B(){clearTimeout(H);const t=document.hidden?6e4:1e3,e=t-Date.now()%t+25;H=setTimeout(()=>{f(),B()},e)}document.addEventListener("visibilitychange",()=>{y="",C(),f(),B()}),f(),B();const w=[{id:"default",label:"Default",icon:"\u{1F550}"},{id:"lcd",label:"LCD Green",icon:"\u{1F49A}"},{id:"lcd-blue",label:"LCD Blue",icon:"\u{1F499}"},{id:"lcd-amber",label:"LCD Amber",icon:"\u{1F7E0}"},{id:"lcd-retro",label:"LCD Retro",icon:"\u{1F7E9}"},{id:"lcd-taxi",label:"LCD Taxi",icon:"\u{1F7E1}"},{id:"flip",label:"Flip Clock",icon:"\u{1F4DF}"},{id:"binary",label:"Binary",icon:"\u{1F4BB}"},{id:"analog",label:"Analog",icon:"\u23F0"},{id:"roman",label:"Roman",icon:"\u{1F3DB}\uFE0F"}];let L='<div class="clock-style-grid">';w.forEach(t=>{L+=`<label class="clock-style-option">
       <input type="radio" name="clock-style-radio" value="${t.id}">
       <span class="clock-style-card"><span class="clock-style-icon">${t.icon}</span><span class="clock-style-label">${t.label}</span></span>
     </label>`}),L+="</div>",injectModal("clock-settings-modal",`<div id="clock-settings-modal" class="weather-modal">
@@ -2066,7 +2066,7 @@ This can take ~30-60s\u2026`);try{const{body:v}=await P("/deploy",{method:"POST"
         <button id="clock-settings-save">Save</button>
       </div>
     </div>
-  </div>`);const o=document.getElementById("clock-settings-modal"),p=document.getElementById("clock-chimes-toggle"),l=document.getElementById("clock-chime-volume"),y=document.getElementById("clock-volume-section");function u(){const t=safeGet("clock-style")||"default",e=o.querySelector(`input[value="${t}"]`);e&&(e.checked=!0),p.checked=safeGet("clock-chimes")==="true",l.value=safeGet("clock-chime-volume")||"50",y.style.opacity=p.checked?"1":"0.4"}p?.addEventListener("change",()=>{y.style.opacity=p.checked?"1":"0.4"}),document.getElementById("clock-settings")?.addEventListener("click",()=>{u(),o.classList.add("show")}),document.getElementById("clock-chime-test")?.addEventListener("click",()=>{const t=parseInt(l.value,10)/100,e=new Audio("/assets/sounds/church-bell.mp3");e.volume=t,e.play().catch(()=>{})}),document.getElementById("clock-settings-save")?.addEventListener("click",()=>{const t=o.querySelector('input[name="clock-style-radio"]:checked'),e=t?t.value:"default";safeSet("clock-style",e),safeSet("clock-chimes",String(p.checked)),safeSet("clock-chime-volume",l.value),A=e,g="",C(),f(),B(),o.classList.remove("show"),showNotification("Clock settings saved","success",2e3)}),document.getElementById("clock-settings-cancel")?.addEventListener("click",()=>{o.classList.remove("show")}),wireModal(o),o?.querySelectorAll('input[name="clock-style-radio"]').forEach(t=>{t.addEventListener("change",()=>{A=t.value,g="",C(),f()})})})(),(function(){const x=new ErrorHandler;injectModal("calendar-modal",`<div id="calendar-modal" class="weather-modal">
+  </div>`);const o=document.getElementById("clock-settings-modal"),u=document.getElementById("clock-chimes-toggle"),l=document.getElementById("clock-chime-volume"),g=document.getElementById("clock-volume-section");function p(){const t=safeGet("clock-style")||"default",e=o.querySelector(`input[value="${t}"]`);e&&(e.checked=!0),u.checked=safeGet("clock-chimes")==="true",l.value=safeGet("clock-chime-volume")||"50",g.style.opacity=u.checked?"1":"0.4"}u?.addEventListener("change",()=>{g.style.opacity=u.checked?"1":"0.4"}),document.getElementById("clock-settings")?.addEventListener("click",()=>{p(),o.classList.add("show")}),document.getElementById("clock-chime-test")?.addEventListener("click",()=>{const t=parseInt(l.value,10)/100,e=new Audio("/assets/sounds/church-bell.mp3");e.volume=t,e.play().catch(()=>{})}),document.getElementById("clock-settings-save")?.addEventListener("click",()=>{const t=o.querySelector('input[name="clock-style-radio"]:checked'),e=t?t.value:"default";safeSet("clock-style",e),safeSet("clock-chimes",String(u.checked)),safeSet("clock-chime-volume",l.value),A=e,y="",C(),f(),B(),o.classList.remove("show"),showNotification("Clock settings saved","success",2e3)}),document.getElementById("clock-settings-cancel")?.addEventListener("click",()=>{o.classList.remove("show")}),wireModal(o),o?.querySelectorAll('input[name="clock-style-radio"]').forEach(t=>{t.addEventListener("change",()=>{A=t.value,y="",C(),f()})})})(),(function(){const x=new ErrorHandler;injectModal("calendar-modal",`<div id="calendar-modal" class="weather-modal">
     <div class="weather-modal-content" style="min-width:560px;max-width:720px;">
       <h3>\u{1F4C5} Calendar</h3>
       <div id="calendar-upcoming" style="margin:0 0 14px;">
@@ -2112,9 +2112,9 @@ This can take ~30-60s\u2026`);try{const{body:v}=await P("/deploy",{method:"POST"
         </details>
       </div>
       <div class="weather-modal-buttons"><button id="calendar-close">Close</button></div>
-    </div></div>`);const E=()=>({icon:document.querySelector(".calendar-widget-icon"),text:document.querySelector(".calendar-widget-text")});function R(b,d){const v=new Date(b),S=new Date;S.setHours(0,0,0,0);const O=new Date(v);O.setHours(0,0,0,0);const m=Math.round((O-S)/864e5),f=m===0?"Today":m===1?"Tomorrow":v.toLocaleDateString(void 0,{weekday:"short",month:"short",day:"numeric"}),B=d?"all-day":v.toLocaleTimeString(void 0,{hour:"numeric",minute:"2-digit"});return`${f} ${B}`}async function h(){const b=new Date(Date.now()-864e5),d=new Date(Date.now()+14*864e5),v=await fetch(`/api/v1/calendar/events?start=${b.toISOString()}&end=${d.toISOString()}`,{cache:"no-store"});if(v.status===404)return{notConfigured:!0};if(!v.ok)throw new Error(`Calendar API HTTP ${v.status}`);return v.json()}function P(b){const d=E();if(!d.icon||!d.text)return;const v=b&&Array.isArray(b.events)?b.events:[];if(!v.length){d.icon.textContent="\u{1F4C5}",d.text.textContent="No calendar";return}const S=v[0];d.icon.textContent=S.allDay?"\u{1F5D3}\uFE0F":"\u23F0",d.text.innerHTML=`${escapeHtml(S.title||"Untitled")}
-      <span style="color:var(--muted);font-size:0.78em;">\xB7 ${escapeHtml(R(S.start,S.allDay))}</span>`}function A(b){const d=document.getElementById("calendar-upcoming-list");if(!d)return;const v=b&&Array.isArray(b.events)?b.events:[];if(!v.length){d.innerHTML='<div style="color:var(--muted);font-size:0.85rem;">No upcoming appointments.</div>';return}d.innerHTML=v.slice(0,12).map(S=>`<div style="display:flex;gap:8px;align-items:baseline;">
-         <span style="font-size:0.78rem;color:var(--muted);white-space:nowrap;">${escapeHtml(R(S.start,S.allDay))}</span>
+    </div></div>`);const E=()=>({icon:document.querySelector(".calendar-widget-icon"),text:document.querySelector(".calendar-widget-text")});function j(b,d){const v=new Date(b),S=new Date;S.setHours(0,0,0,0);const O=new Date(v);O.setHours(0,0,0,0);const m=Math.round((O-S)/864e5),f=m===0?"Today":m===1?"Tomorrow":v.toLocaleDateString(void 0,{weekday:"short",month:"short",day:"numeric"}),B=d?"all-day":v.toLocaleTimeString(void 0,{hour:"numeric",minute:"2-digit"});return`${f} ${B}`}async function h(){const b=new Date(Date.now()-864e5),d=new Date(Date.now()+14*864e5),v=await fetch(`/api/v1/calendar/events?start=${b.toISOString()}&end=${d.toISOString()}`,{cache:"no-store"});if(v.status===404)return{notConfigured:!0};if(!v.ok)throw new Error(`Calendar API HTTP ${v.status}`);return v.json()}function P(b){const d=E();if(!d.icon||!d.text)return;const v=b&&Array.isArray(b.events)?b.events:[];if(!v.length){d.icon.textContent="\u{1F4C5}",d.text.textContent="No calendar";return}const S=v[0];d.icon.textContent=S.allDay?"\u{1F5D3}\uFE0F":"\u23F0",d.text.innerHTML=`${escapeHtml(S.title||"Untitled")}
+      <span style="color:var(--muted);font-size:0.78em;">\xB7 ${escapeHtml(j(S.start,S.allDay))}</span>`}function A(b){const d=document.getElementById("calendar-upcoming-list");if(!d)return;const v=b&&Array.isArray(b.events)?b.events:[];if(!v.length){d.innerHTML='<div style="color:var(--muted);font-size:0.85rem;">No upcoming appointments.</div>';return}d.innerHTML=v.slice(0,12).map(S=>`<div style="display:flex;gap:8px;align-items:baseline;">
+         <span style="font-size:0.78rem;color:var(--muted);white-space:nowrap;">${escapeHtml(j(S.start,S.allDay))}</span>
          <span style="font-size:0.85rem;">${escapeHtml(S.title||"Untitled")}</span>
          ${S.location?`<span style="font-size:0.75rem;color:var(--muted);">${escapeHtml(S.location)}</span>`:""}
        </div>`).join("")}async function D(){const b=document.getElementById("calendar-sources-list");if(!b)return;let d=[];try{const v=await fetch("/api/v1/calendar/sources",{cache:"no-store"});if(v.ok){const S=await v.json();d=S&&Array.isArray(S.sources)?S.sources:Array.isArray(S)?S:[]}}catch{}if(!d.length){b.innerHTML='<div style="font-size:0.82rem;color:var(--muted);">No calendars connected. Deploy Radicale from the App Selector to auto-connect one, or add a CalDAV/ICS URL below.</div>';return}b.innerHTML=d.map(v=>`
@@ -2124,7 +2124,7 @@ This can take ~30-60s\u2026`);try{const{body:v}=await P("/deploy",{method:"POST"
         <button class="cal-src-toggle" data-id="${escapeHtml(v.id)}" data-enabled="${v.enabled!==!1?"1":"0"}"
           style="font-size:0.75rem;padding:2px 8px;">${v.enabled!==!1?"\u2713 on":"off"}</button>
         <button class="cal-src-del" data-id="${escapeHtml(v.id)}" style="font-size:0.75rem;padding:2px 8px;color:var(--err-fg);">remove</button>
-      </div>`).join(""),b.querySelectorAll(".cal-src-toggle").forEach(v=>v.addEventListener("click",async()=>{const S=v.dataset.id,O=v.dataset.enabled!=="1";await fetch(`/api/v1/calendar/sources/${encodeURIComponent(S)}`,{method:"PUT",headers:{"Content-Type":"application/json"},body:JSON.stringify({enabled:O})}),D(),j()})),b.querySelectorAll(".cal-src-del").forEach(v=>v.addEventListener("click",async()=>{const S=v.dataset.id;await fetch(`/api/v1/calendar/sources/${encodeURIComponent(S)}`,{method:"DELETE"}),D(),j()}))}async function j(){if(!j._inFlight){j._inFlight=!0;try{const b=await h();P(b),document.getElementById("calendar-modal").style.display==="flex"&&A(b)}catch(b){x.log(b,"calendar-widget");const d=E();d.text&&(d.text.textContent="Calendar offline")}finally{j._inFlight=!1}}}function g(){document.getElementById("calendar-modal").style.display="flex",D(),j()}function $(){document.getElementById("calendar-modal").style.display="none"}function k(){return{type:document.getElementById("cal-add-type").value,name:document.getElementById("cal-add-name").value.trim(),url:document.getElementById("cal-add-url").value.trim(),user:document.getElementById("cal-add-user").value.trim(),pass:document.getElementById("cal-add-pass").value}}function M(b){document.getElementById("cal-add-status").textContent=b}document.getElementById("cal-add-test").addEventListener("click",async()=>{const b=k();if(!b.url){M("Enter a URL first.");return}M("Testing\u2026");try{const v=await(await fetch("/api/v1/calendar/discover",{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify({url:b.url,user:b.user,pass:b.pass})})).json(),S=v&&v.probe;S&&S.ok?M(`\u2713 Reachable (${S.server||"server"})${S.looksLikeCalendar?" \u2014 looks like a calendar":""}`):M(`\u2717 ${S&&S.error?S.error:"Not reachable"}`)}catch(d){M(`\u2717 ${d.message}`)}}),document.getElementById("cal-add-save").addEventListener("click",async()=>{const b=k();if(!b.name||!b.url){M("Name and URL are required.");return}try{const d=await fetch("/api/v1/calendar/sources",{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify({name:b.name,type:b.type,url:b.url,user:b.user,pass:b.pass})});if(!d.ok){const v=await d.json().catch(()=>({}));M(`\u2717 ${v.error||v.message||`HTTP ${d.status}`}`);return}M("Saved."),document.getElementById("cal-add-details").open=!1,["cal-add-name","cal-add-url","cal-add-user","cal-add-pass"].forEach(v=>{document.getElementById(v).value=""}),D(),j()}catch(d){M(`\u2717 ${d.message}`)}});const T=document.getElementById("calendar-widget");T&&T.addEventListener("click",g);const z=document.getElementById("calendar-settings");z&&z.addEventListener("click",b=>{b.stopPropagation(),g()});const C=document.getElementById("calendar-close");C&&C.addEventListener("click",$),window.refreshCalendarWidget=j;const H=typeof DC<"u"&&DC.POLL&&DC.POLL.CALENDAR||3e5;setInterval(j,H),setTimeout(j,400)})(),(function(){const x=new ErrorHandler;injectModal("ai-connect-modal",`<div id="ai-connect-modal" class="weather-modal">
+      </div>`).join(""),b.querySelectorAll(".cal-src-toggle").forEach(v=>v.addEventListener("click",async()=>{const S=v.dataset.id,O=v.dataset.enabled!=="1";await fetch(`/api/v1/calendar/sources/${encodeURIComponent(S)}`,{method:"PUT",headers:{"Content-Type":"application/json"},body:JSON.stringify({enabled:O})}),D(),R()})),b.querySelectorAll(".cal-src-del").forEach(v=>v.addEventListener("click",async()=>{const S=v.dataset.id;await fetch(`/api/v1/calendar/sources/${encodeURIComponent(S)}`,{method:"DELETE"}),D(),R()}))}async function R(){if(!R._inFlight){R._inFlight=!0;try{const b=await h();P(b),document.getElementById("calendar-modal").style.display==="flex"&&A(b)}catch(b){x.log(b,"calendar-widget");const d=E();d.text&&(d.text.textContent="Calendar offline")}finally{R._inFlight=!1}}}function y(){document.getElementById("calendar-modal").style.display="flex",D(),R()}function $(){document.getElementById("calendar-modal").style.display="none"}function k(){return{type:document.getElementById("cal-add-type").value,name:document.getElementById("cal-add-name").value.trim(),url:document.getElementById("cal-add-url").value.trim(),user:document.getElementById("cal-add-user").value.trim(),pass:document.getElementById("cal-add-pass").value}}function H(b){document.getElementById("cal-add-status").textContent=b}document.getElementById("cal-add-test").addEventListener("click",async()=>{const b=k();if(!b.url){H("Enter a URL first.");return}H("Testing\u2026");try{const v=await(await fetch("/api/v1/calendar/discover",{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify({url:b.url,user:b.user,pass:b.pass})})).json(),S=v&&v.probe;S&&S.ok?H(`\u2713 Reachable (${S.server||"server"})${S.looksLikeCalendar?" \u2014 looks like a calendar":""}`):H(`\u2717 ${S&&S.error?S.error:"Not reachable"}`)}catch(d){H(`\u2717 ${d.message}`)}}),document.getElementById("cal-add-save").addEventListener("click",async()=>{const b=k();if(!b.name||!b.url){H("Name and URL are required.");return}try{const d=await fetch("/api/v1/calendar/sources",{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify({name:b.name,type:b.type,url:b.url,user:b.user,pass:b.pass})});if(!d.ok){const v=await d.json().catch(()=>({}));H(`\u2717 ${v.error||v.message||`HTTP ${d.status}`}`);return}H("Saved."),document.getElementById("cal-add-details").open=!1,["cal-add-name","cal-add-url","cal-add-user","cal-add-pass"].forEach(v=>{document.getElementById(v).value=""}),D(),R()}catch(d){H(`\u2717 ${d.message}`)}});const T=document.getElementById("calendar-widget");T&&T.addEventListener("click",y);const z=document.getElementById("calendar-settings");z&&z.addEventListener("click",b=>{b.stopPropagation(),y()});const C=document.getElementById("calendar-close");C&&C.addEventListener("click",$),window.refreshCalendarWidget=R;const M=typeof DC<"u"&&DC.POLL&&DC.POLL.CALENDAR||3e5;setInterval(R,M),setTimeout(R,400)})(),(function(){const x=new ErrorHandler;injectModal("ai-connect-modal",`<div id="ai-connect-modal" class="weather-modal">
     <div class="weather-modal-content" style="min-width:560px;max-width:720px;">
       <h3>\u{1F916} Connect your AI assistant</h3>
       <div id="aiconn-intro" style="font-size:0.85rem;color:var(--muted);margin-bottom:12px;">
@@ -2178,12 +2178,12 @@ This can take ~30-60s\u2026`);try{const{body:v}=await P("/deploy",{method:"POST"
         <span id="aiconn-status" style="flex:1;font-size:0.78rem;color:var(--muted);align-self:center;"></span>
         <button id="aiconn-close">Close</button>
       </div>
-    </div></div>`);const E=g=>document.getElementById(g);let R=null;function h(g){E("aiconn-status").textContent=g}async function P(){try{const g=await secureFetch("/api/v1/mcp/info");if(!g.ok)throw new Error(`HTTP ${g.status}`);const $=await g.json();R=$,E("aiconn-endpoint").style.display="block",E("aiconn-endpoint-url").textContent=$.endpoint,E("aiconn-tools").textContent=`${$.toolCount} tools \xB7 MCP ${$.protocolVersion} \xB7 DashCaddy v${$.serverVersion}`}catch(g){x.log(g,"ai-connect-info"),h("MCP endpoint unavailable on this build.")}}async function A(){const g=E("aiconn-connections");try{const k=await(await secureFetch("/api/v1/mcp/connections")).json().catch(()=>({})),M=k&&Array.isArray(k.connections)?k.connections:[];if(!M.length){g.innerHTML='<div style="font-size:0.8rem;color:var(--muted);">No connections yet \u2014 choose an assistant above.</div>';return}g.innerHTML=M.map(T=>`
+    </div></div>`);const E=y=>document.getElementById(y);let j=null;function h(y){E("aiconn-status").textContent=y}async function P(){try{const y=await secureFetch("/api/v1/mcp/info");if(!y.ok)throw new Error(`HTTP ${y.status}`);const $=await y.json();j=$,E("aiconn-endpoint").style.display="block",E("aiconn-endpoint-url").textContent=$.endpoint,E("aiconn-tools").textContent=`${$.toolCount} tools \xB7 MCP ${$.protocolVersion} \xB7 DashCaddy v${$.serverVersion}`}catch(y){x.log(y,"ai-connect-info"),h("MCP endpoint unavailable on this build.")}}async function A(){const y=E("aiconn-connections");try{const k=await(await secureFetch("/api/v1/mcp/connections")).json().catch(()=>({})),H=k&&Array.isArray(k.connections)?k.connections:[];if(!H.length){y.innerHTML='<div style="font-size:0.8rem;color:var(--muted);">No connections yet \u2014 choose an assistant above.</div>';return}y.innerHTML=H.map(T=>`
         <div style="display:flex;gap:8px;align-items:center;font-size:0.8rem;">
           <span style="flex:1;">${escapeHtml(T.name)}
             <span style="color:var(--muted);">\xB7 ${(T.scopes||[]).join(",")} \xB7 since ${escapeHtml((T.createdAt||"").slice(0,10))}${T.lastUsed?" \xB7 last used "+escapeHtml(String(T.lastUsed).slice(0,10)):""}</span></span>
           <button class="aiconn-revoke" data-id="${escapeHtml(T.id)}" style="font-size:0.75rem;color:var(--err-fg);">Revoke</button>
-        </div>`).join(""),g.querySelectorAll(".aiconn-revoke").forEach(T=>T.addEventListener("click",async()=>{T.disabled=!0;try{const z=await secureFetch(`/api/v1/auth/keys/${encodeURIComponent(T.dataset.id)}`,{method:"DELETE"});if(z.ok)h("Connection revoked."),A();else{const C=await z.json().catch(()=>({}));h(C.error||"Revoke failed."),T.disabled=!1}}catch(z){h("Revoke failed: "+z.message),T.disabled=!1}}))}catch{g.innerHTML='<div style="font-size:0.8rem;color:var(--muted);">Could not load connections.</div>'}}async function D(g){h(`Creating ${g} connection\u2026`);try{const $=await secureFetch("/api/v1/mcp/config",{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify({client:g})}),k=await $.json().catch(()=>({}));if(!$.ok||!k.key){h(k.error||`Failed (HTTP ${$.status})`);return}E("aiconn-key").textContent=k.key;const M=k.httpConfig?JSON.stringify(k.httpConfig,null,2):"";E("aiconn-snippet").textContent=M||"(see note below)",E("aiconn-client-note").textContent=k.note||"",E("aiconn-config-title").textContent=g==="chatgpt"?"Access key (ChatGPT note below):":"Your access key (shown once):",E("aiconn-step-pick").style.display="none",E("aiconn-step-config").style.display="block",h(""),A()}catch($){x.log($,"ai-connect-create"),h("Failed: "+$.message)}}function j(g,$){navigator.clipboard&&navigator.clipboard.writeText?navigator.clipboard.writeText(g).then(()=>h($)).catch(()=>h("Copy failed \u2014 select manually.")):h("Clipboard unavailable \u2014 select manually.")}E("ai-connect-btn").addEventListener("click",()=>{E("ai-connect-modal").style.display="flex",E("aiconn-step-pick").style.display="block",E("aiconn-step-config").style.display="none",h(""),P(),A()}),E("aiconn-close").addEventListener("click",()=>{E("ai-connect-modal").style.display="none"}),E("aiconn-back").addEventListener("click",()=>{E("aiconn-step-config").style.display="none",E("aiconn-step-pick").style.display="block"}),document.querySelectorAll(".aiconn-client-btn").forEach(g=>g.addEventListener("click",()=>D(g.dataset.client))),E("aiconn-copy-key").addEventListener("click",()=>j(E("aiconn-key").textContent,"Key copied \u2014 paste it into your client.")),E("aiconn-copy-snippet").addEventListener("click",()=>j(E("aiconn-snippet").textContent,"Config copied.")),E("aiconn-copy-endpoint").addEventListener("click",()=>j(R?R.endpoint:E("aiconn-endpoint-url").textContent,"Endpoint copied."))})(),(function(){async function x(){try{const j=await(await fetch("/api/v1/health-checks/status")).json();if(!j.success||!j.status)return;for(const[g,$]of Object.entries(j.status)){const k=document.getElementById("uptime-"+g),M=document.getElementById("uptime-bar-"+g);if(!k)continue;const T=$.uptime?.["24h"];if(T!=null){const z=T.toFixed(1);k.textContent=`${z}% uptime`,k.className="uptime-chip",T>=99.9?k.classList.add("excellent"):T>=99?k.classList.add("good"):T>=95?k.classList.add("degraded"):k.classList.add("poor"),M&&(M.style.width=z+"%")}}}catch{console.warn("[Card Badges] Health check API unavailable")}}let E;try{E=new Set(JSON.parse(safeSessionGet("dismissed-updates")||"[]"))}catch{E=new Set}let R=[];async function h(D){try{const g=await(await fetch("/api/v1/updates/available")).json();if(!g.success)return;document.querySelectorAll(".update-available-badge").forEach(k=>k.classList.remove("visible"));const $=g.updates||[];if(R=$,D&&$.length>0){const k=window._lastKnownUpdateCount||0;k>0&&$.length>k&&showNotification(`${$.length} container update(s) available \u2014 click Update Management to review.`,"info"),window._lastKnownUpdateCount=$.length}if(!$.length)return;for(const k of $){const M=window.APPS||[];for(const T of M)if(T.containerId===k.containerId||T.id===k.containerName||T.name===k.containerName){if(E.has(T.id))break;const z=document.getElementById("update-badge-"+T.id),C=document.getElementById("update-btn-"+T.id);z&&(z.classList.add("visible"),z.title="Update available \u2014 click to open Update Management.",z.style.cursor="pointer",z.onclick=H=>{H.stopPropagation(),window.openUpdateModal&&window.openUpdateModal(T.id)}),C&&(C.style.background="#f97316",C.style.borderColor="#f97316",C.style.boxShadow="0 0 6px #f9731688",C.title="Update available \u2014 click to open Update Management.");break}}}catch{console.warn("[Card Badges] Updates API unavailable")}}function P(){setTimeout(()=>{x(),h()},5e3),setInterval(()=>{x(),h(!0)},6e4)}const A=window.refreshAll;A&&(window.refreshAll=async function(){try{await A(),setTimeout(x,1e3)}catch(D){console.warn("[Card Badges] Error in refreshAll hook:",D.message)}}),P()})(),(function(){var x=null,E=null,R={},h={dark:"Dark",light:"Light",blue:"Blue",black:"Black",nord:"Nord",dracula:"Dracula","solarized-dark":"Solarized Dark","solarized-light":"Solarized Light",taxi:"Taxi",ocean:"Ocean"},P=[["bg","Background","base"],["card-base","Card","base"],["fg","Text","base"],["muted","Muted Text","base"],["border","Border","base"],["accent","Accent","accent"],["accent-strong","Accent Strong","accent"],["ok-bg","OK Background","status"],["ok-fg","OK Text","status"],["bad-bg","Error Bg","status"],["bad-fg","Error Text","status"],["dot-ok","Dot OK","status"],["dot-bad","Dot Error","status"],["uptime","Uptime Bar","status"],["hover","Hover","advanced"],["card-hover","Card Hover","advanced"],["base","Tags/Badges","advanced"],["fg-muted","Dim Text","advanced"],["success","Success","advanced"],["error","Error","advanced"],["warning","Warning","advanced"]],A=document.getElementById("theme");if(!A)return;var D=document.getElementById("theme-label");function j(n){if(h[n])return h[n];var r=safeGetJSON(window.USER_THEMES_KEY,{});return r[n]&&r[n].name||n}function g(){D&&(D.textContent=j(window.getActiveTheme()))}A.addEventListener("click",function(){var n=window.THEMES.slice(),r=window.getActiveTheme(),a=n.indexOf(r),i=n[(a+1)%n.length];window.applyTheme(i),g()}),g();function $(){var n={base:"Base Colors",accent:"Accent",status:"Status",advanced:"Advanced (auto-derived)"},r={};P.forEach(function(i){r[i[2]]||(r[i[2]]=[]),r[i[2]].push(i)});var a="";return Object.keys(n).forEach(function(i){i==="advanced"?(a+='<div id="theme-builder-advanced-toggle" class="theme-builder-advanced-toggle" style="margin:12px 0 4px;cursor:pointer;color:var(--accent);font-size:.85rem;user-select:none;">Show advanced colors &#9660;</div>',a+='<div id="theme-builder-advanced" class="theme-builder-section" style="display:none;">'):a+='<div class="theme-builder-section">',a+='<div class="theme-builder-section-title">'+n[i]+"</div>",(r[i]||[]).forEach(function(c){a+='<div class="theme-builder-row"><span class="theme-builder-label">'+c[1]+'</span><input type="color" class="theme-builder-color" data-prop="'+c[0]+'"'+(i==="advanced"?' data-advanced="1"':"")+' value="#000000" /><span class="theme-builder-hex" data-hex="'+c[0]+'">#000000</span></div>'}),a+="</div>"}),a}function k(){return window.THEMES.map(function(n){return'<option value="'+n+'">'+j(n)+"</option>"}).join("")}var M='<div id="theme-builder-modal" class="weather-modal"><div class="weather-modal-content" style="min-width:420px;max-width:560px;"><h3>Theme Builder</h3><div id="theme-builder-existing" style="margin-bottom:16px;display:none;"><label style="font-size:.85rem;color:var(--muted);margin-right:8px;">Edit:</label><select id="theme-builder-edit-select" style="padding:6px 10px;background:var(--card-bg);color:var(--fg);border:1px solid var(--border);border-radius:6px;font-size:.85rem;margin-right:8px;"><option value="">\u2014 New Theme \u2014</option></select><button id="theme-builder-delete" style="padding:4px 10px;background:color-mix(in srgb,var(--bad-fg) 15%,transparent);border:1px solid var(--bad-fg);color:var(--bad-fg);border-radius:6px;font-size:.8rem;cursor:pointer;">Delete</button></div><div style="margin-bottom:16px;"><label style="font-size:.85rem;color:var(--muted);margin-right:8px;">Name:</label><input type="text" id="theme-builder-name" maxlength="20" placeholder="My Theme" style="padding:6px 10px;background:var(--card-bg);color:var(--fg);border:1px solid var(--border);border-radius:6px;font-size:.85rem;width:140px;" /></div><div style="margin-bottom:16px;display:flex;align-items:center;"><label style="font-size:.85rem;color:var(--muted);margin-right:8px;cursor:pointer;" for="theme-builder-lightbg"><input type="checkbox" id="theme-builder-lightbg" style="margin-right:6px;cursor:pointer;vertical-align:middle;" />Light background (use dark logo)</label></div><div style="margin-bottom:16px;"><label style="font-size:.85rem;color:var(--muted);margin-right:8px;">Start from:</label><select id="theme-builder-start" style="padding:6px 10px;background:var(--card-bg);color:var(--fg);border:1px solid var(--border);border-radius:6px;font-size:.85rem;">'+k()+'</select></div><div class="theme-builder-preview" id="theme-builder-preview"><div class="theme-builder-card" id="theme-preview-card"><div class="preview-title">Sample Card</div><div class="preview-muted">Secondary text preview</div><div class="preview-badges"><span class="preview-badge" id="preview-badge-ok">ON</span><span class="preview-badge" id="preview-badge-bad">OFF</span></div><div class="preview-dots"><span><span class="preview-dot" id="preview-dot-ok"></span> Online</span><span><span class="preview-dot" id="preview-dot-bad"></span> Offline</span></div><button class="preview-btn" id="preview-accent-btn">Accent Button</button></div></div>'+$()+'<div class="weather-modal-buttons"><button id="theme-builder-cancel">Cancel</button><button id="theme-builder-import" style="margin-left:auto;" title="Import theme from JSON file">Import</button><button id="theme-builder-export" title="Export theme as JSON file">Export</button><button id="theme-builder-save" class="btn-accent">Save Theme</button></div></div></div>';injectModal("theme-builder-modal",M);var T=document.getElementById("theme-builder-modal"),z=document.getElementById("theme-builder-start"),C=document.getElementById("theme-builder-name"),H=document.getElementById("theme-builder-edit-select"),b=document.getElementById("theme-builder-existing"),d=document.getElementById("theme-builder-lightbg"),v=T.querySelectorAll(".theme-builder-color"),S=document.getElementById("theme-builder-advanced"),O=document.getElementById("theme-builder-advanced-toggle"),m=document.getElementById("theme-builder-export"),f=!1;O.addEventListener("click",function(){f=!f,S.style.display=f?"":"none",O.innerHTML=f?"Hide advanced colors &#9650;":"Show advanced colors &#9660;"});function B(){var n={};return v.forEach(function(r){n[r.dataset.prop]=r.value}),n["card-bg"]=n["card-base"],n}function w(){var n={};return v.forEach(function(r){r.dataset.advanced||(n[r.dataset.prop]=r.value)}),n["card-bg"]=n["card-base"],d.checked&&(n.lightBg=!0),n}function L(){var n=w(),r=window.deriveExtendedColors?window.deriveExtendedColors(n):{};v.forEach(function(a){if(a.dataset.advanced&&!R[a.dataset.prop]){var i=r[a.dataset.prop]||"#333333";a.value=i;var c=T.querySelector('[data-hex="'+a.dataset.prop+'"]');c&&(c.textContent=i.toUpperCase())}})}function o(n){var r=window.THEME_COLORS[n];r&&(R={},v.forEach(function(a){var i=r[a.dataset.prop]||"#000000";(i.startsWith("rgba")||i.startsWith("color-mix"))&&(i="#333333"),a.value=i;var c=T.querySelector('[data-hex="'+a.dataset.prop+'"]');c&&(c.textContent=i.toUpperCase())}),d.checked=!!r.lightBg,l())}function p(n){var r=safeGetJSON(window.USER_THEMES_KEY,{}),a=r[n];a&&(R={},v.forEach(function(i){var c=a[i.dataset.prop]||"#000000";i.value=c;var I=T.querySelector('[data-hex="'+i.dataset.prop+'"]');I&&(I.textContent=c.toUpperCase()),i.dataset.advanced&&a[i.dataset.prop]&&(R[i.dataset.prop]=!0)}),C.value=a.name||"",d.checked=!!a.lightBg,L(),l())}function l(){var n=B(),r=document.getElementById("theme-builder-preview"),a=document.getElementById("theme-preview-card"),i=a.querySelector(".preview-title"),c=a.querySelector(".preview-muted"),I=document.getElementById("preview-badge-ok"),N=document.getElementById("preview-badge-bad"),U=document.getElementById("preview-dot-ok"),_=document.getElementById("preview-dot-bad"),F=document.getElementById("preview-accent-btn"),q=a.querySelector(".preview-dots");r.style.background=n.bg,a.style.background=n["card-base"],a.style.borderColor=n.border,i.style.color=n.fg,c.style.color=n.muted,I.style.background=n["ok-bg"],I.style.color=n["ok-fg"],N.style.background=n["bad-bg"],N.style.color=n["bad-fg"],U.style.background=n["dot-ok"],_.style.background=n["dot-bad"],q.style.color=n.fg,F.style.background=n.accent,F.style.color=n.bg}function y(n){var r=window.deriveExtendedColors?window.deriveExtendedColors(n):{};window.THEME_PROPS.forEach(function(a){var i=n[a]||r[a];i&&document.documentElement.style.setProperty("--"+a,i)})}v.forEach(function(n){n.addEventListener("input",function(){var r=T.querySelector('[data-hex="'+n.dataset.prop+'"]');r&&(r.textContent=n.value.toUpperCase()),n.dataset.advanced?R[n.dataset.prop]=!0:L(),l(),y(B())})}),d.addEventListener("change",function(){L(),l(),y(B())}),z.addEventListener("change",function(){R={},o(z.value),y(B())});function u(){var n=safeGetJSON(window.USER_THEMES_KEY,{}),r=Object.keys(n);H.innerHTML='<option value="">\u2014 New Theme \u2014</option>',r.forEach(function(a){var i=document.createElement("option");i.value=a,i.textContent=n[a].name||a,H.appendChild(i)}),b.style.display=r.length?"":"none"}function t(){z.innerHTML=k()}H.addEventListener("change",function(){var n=this.value;n?(E=n,p(n),y(B())):(E=null,R={},C.value="",z.value=window.getActiveTheme(),o(z.value)),m.style.display=E?"":"none"});function e(){x=window.getActiveTheme(),E=null,R={},f=!1,S.style.display="none",O.innerHTML="Show advanced colors &#9660;",u(),t();var n=safeGetJSON(window.USER_THEMES_KEY,{});n[x]?(H.value=x,E=x,p(x)):(H.value="",C.value="",z.value=x,o(x)),m.style.display=E?"":"none",T.classList.add("show")}var s=document.getElementById("theme-customize-btn");s&&s.addEventListener("click",function(){e()}),document.getElementById("theme-builder-save").addEventListener("click",function(){var n=B(),r=C.value.trim();if(!r){showNotification("Please enter a theme name","warning",3e3),C.focus();return}var a=safeGetJSON(window.USER_THEMES_KEY,{}),i,c=null;if(E){i=E;var I=window.slugifyThemeName(r,E);if(I!==E){c=E,delete a[E];var N=window.THEMES.indexOf(E);N!==-1&&window.THEMES.splice(N,1),delete window.THEME_COLORS[E],i=I}}else i=window.slugifyThemeName(r);var U={name:r};d.checked&&(U.lightBg=!0),window.THEME_PROPS.forEach(function(F){n[F]&&(U[F]=n[F])}),a[i]=U,safeSet(window.USER_THEMES_KEY,JSON.stringify(a)),window.clearCustomProperties(),window.injectUserThemeStyles(),window.applyTheme(i),T.classList.remove("show"),g();var _={};window.THEME_PROPS.forEach(function(F){n[F]&&(_[F]=n[F])}),c&&secureFetch("/api/v1/themes/"+c,{method:"DELETE"}).catch(function(){}),secureFetch("/api/v1/themes/"+i,{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify({name:r,colors:_,lightBg:d.checked})}).then(function(){showNotification(r+" theme saved","success",3e3)}).catch(function(){showNotification(r+" theme saved locally (server sync failed)","warning",3e3)})}),document.getElementById("theme-builder-cancel").addEventListener("click",function(){T.classList.remove("show"),window.clearCustomProperties(),x&&window.applyTheme(x)}),document.getElementById("theme-builder-delete").addEventListener("click",function(){if(E){var n=safeGetJSON(window.USER_THEMES_KEY,{}),r=n[E]?n[E].name:E;if(confirm('Delete "'+r+'" theme?')){var a=E;delete n[a],safeSet(window.USER_THEMES_KEY,JSON.stringify(n));var i=window.THEMES.indexOf(a);i!==-1&&window.THEMES.splice(i,1),delete window.THEME_COLORS[a],window.clearCustomProperties(),window.injectUserThemeStyles();var c=x&&x!==a?x:"dark";window.applyTheme(c),E=null,T.classList.remove("show"),g(),secureFetch("/api/v1/themes/"+a,{method:"DELETE"}).then(function(){showNotification(r+" theme deleted","success",3e3)}).catch(function(){showNotification(r+" theme deleted locally (server sync failed)","warning",3e3)})}}}),document.getElementById("theme-builder-export").addEventListener("click",function(){if(!E){showNotification("Save the theme first, then export","warning",3e3);return}var n=safeGetJSON(window.USER_THEMES_KEY,{}),r=n[E];if(r){var a={_dashcaddy_theme:!0,version:"1.0",exportDate:new Date().toISOString(),slug:E,name:r.name,lightBg:r.lightBg||!1,colors:{}};window.THEME_PROPS.forEach(function(N){r[N]&&(a.colors[N]=r[N])});var i=new Blob([JSON.stringify(a,null,2)],{type:"application/json"}),c=URL.createObjectURL(i),I=document.createElement("a");I.href=c,I.download=E+"-theme.json",document.body.appendChild(I),I.click(),document.body.removeChild(I),URL.revokeObjectURL(c),showNotification("Theme exported as "+E+"-theme.json","success",3e3)}}),document.getElementById("theme-builder-import").addEventListener("click",function(){var n=document.createElement("input");n.type="file",n.accept=".json",n.onchange=function(r){var a=r.target.files[0];if(a){var i=new FileReader;i.onload=function(c){try{var I=JSON.parse(c.target.result),N,U,_;if(I._dashcaddy_theme&&I.colors)N=I.name||"Imported",U=I.colors,_=I.lightBg||!1;else if(I.name&&(I.bg||I["card-base"]))N=I.name,U={},window.THEME_PROPS.forEach(function(F){I[F]&&(U[F]=I[F])}),_=I.lightBg||!1;else throw new Error("Not a valid DashCaddy theme file");C.value=N,d.checked=!!_,E=null,H.value="",R={},v.forEach(function(F){var q=U[F.dataset.prop]||"#000000";F.value=q;var J=T.querySelector('[data-hex="'+F.dataset.prop+'"]');J&&(J.textContent=q.toUpperCase()),F.dataset.advanced&&U[F.dataset.prop]&&(R[F.dataset.prop]=!0)}),L(),l(),y(B()),m.style.display="none",showNotification('"'+N+'" loaded into builder. Click Save to keep it.',"success",5e3)}catch(F){showNotification("Import failed: "+F.message,"error",5e3)}},i.readAsText(a)}},n.click()}),wireModal(T),T.addEventListener("click",function(n){n.target===T&&(window.clearCustomProperties(),x&&window.applyTheme(x))})})(),(function(){injectModal("license-modal",`<div id="license-modal" class="weather-modal">
+        </div>`).join(""),y.querySelectorAll(".aiconn-revoke").forEach(T=>T.addEventListener("click",async()=>{T.disabled=!0;try{const z=await secureFetch(`/api/v1/auth/keys/${encodeURIComponent(T.dataset.id)}`,{method:"DELETE"});if(z.ok)h("Connection revoked."),A();else{const C=await z.json().catch(()=>({}));h(C.error||"Revoke failed."),T.disabled=!1}}catch(z){h("Revoke failed: "+z.message),T.disabled=!1}}))}catch{y.innerHTML='<div style="font-size:0.8rem;color:var(--muted);">Could not load connections.</div>'}}async function D(y){h(`Creating ${y} connection\u2026`);try{const $=await secureFetch("/api/v1/mcp/config",{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify({client:y})}),k=await $.json().catch(()=>({}));if(!$.ok||!k.key){h(k.error||`Failed (HTTP ${$.status})`);return}E("aiconn-key").textContent=k.key;const H=k.httpConfig?JSON.stringify(k.httpConfig,null,2):"";E("aiconn-snippet").textContent=H||"(see note below)",E("aiconn-client-note").textContent=k.note||"",E("aiconn-config-title").textContent=y==="chatgpt"?"Access key (ChatGPT note below):":"Your access key (shown once):",E("aiconn-step-pick").style.display="none",E("aiconn-step-config").style.display="block",h(""),A()}catch($){x.log($,"ai-connect-create"),h("Failed: "+$.message)}}function R(y,$){navigator.clipboard&&navigator.clipboard.writeText?navigator.clipboard.writeText(y).then(()=>h($)).catch(()=>h("Copy failed \u2014 select manually.")):h("Clipboard unavailable \u2014 select manually.")}E("ai-connect-btn").addEventListener("click",()=>{E("ai-connect-modal").style.display="flex",E("aiconn-step-pick").style.display="block",E("aiconn-step-config").style.display="none",h(""),P(),A()}),E("aiconn-close").addEventListener("click",()=>{E("ai-connect-modal").style.display="none"}),E("aiconn-back").addEventListener("click",()=>{E("aiconn-step-config").style.display="none",E("aiconn-step-pick").style.display="block"}),document.querySelectorAll(".aiconn-client-btn").forEach(y=>y.addEventListener("click",()=>D(y.dataset.client))),E("aiconn-copy-key").addEventListener("click",()=>R(E("aiconn-key").textContent,"Key copied \u2014 paste it into your client.")),E("aiconn-copy-snippet").addEventListener("click",()=>R(E("aiconn-snippet").textContent,"Config copied.")),E("aiconn-copy-endpoint").addEventListener("click",()=>R(j?j.endpoint:E("aiconn-endpoint-url").textContent,"Endpoint copied."))})(),(function(){async function x(){try{const R=await(await fetch("/api/v1/health-checks/status")).json();if(!R.success||!R.status)return;for(const[y,$]of Object.entries(R.status)){const k=document.getElementById("uptime-"+y),H=document.getElementById("uptime-bar-"+y);if(!k)continue;const T=$.uptime?.["24h"];if(T!=null){const z=T.toFixed(1);k.textContent=`${z}% uptime`,k.className="uptime-chip",T>=99.9?k.classList.add("excellent"):T>=99?k.classList.add("good"):T>=95?k.classList.add("degraded"):k.classList.add("poor"),H&&(H.style.width=z+"%")}}}catch{console.warn("[Card Badges] Health check API unavailable")}}let E;try{E=new Set(JSON.parse(safeSessionGet("dismissed-updates")||"[]"))}catch{E=new Set}let j=[];async function h(D){try{const y=await(await fetch("/api/v1/updates/available")).json();if(!y.success)return;document.querySelectorAll(".update-available-badge").forEach(k=>k.classList.remove("visible"));const $=y.updates||[];if(j=$,D&&$.length>0){const k=window._lastKnownUpdateCount||0;k>0&&$.length>k&&showNotification(`${$.length} container update(s) available \u2014 click Update Management to review.`,"info"),window._lastKnownUpdateCount=$.length}if(!$.length)return;for(const k of $){const H=window.APPS||[];for(const T of H)if(T.containerId===k.containerId||T.id===k.containerName||T.name===k.containerName){if(E.has(T.id))break;const z=document.getElementById("update-badge-"+T.id),C=document.getElementById("update-btn-"+T.id);z&&(z.classList.add("visible"),z.title="Update available \u2014 click to open Update Management.",z.style.cursor="pointer",z.onclick=M=>{M.stopPropagation(),window.openUpdateModal&&window.openUpdateModal(T.id)}),C&&(C.style.background="#f97316",C.style.borderColor="#f97316",C.style.boxShadow="0 0 6px #f9731688",C.title="Update available \u2014 click to open Update Management.");break}}}catch{console.warn("[Card Badges] Updates API unavailable")}}function P(){setTimeout(()=>{x(),h()},5e3),setInterval(()=>{x(),h(!0)},6e4)}const A=window.refreshAll;A&&(window.refreshAll=async function(){try{await A(),setTimeout(x,1e3)}catch(D){console.warn("[Card Badges] Error in refreshAll hook:",D.message)}}),P()})(),(function(){var x=null,E=null,j={},h={dark:"Dark",light:"Light",blue:"Blue",black:"Black",nord:"Nord",dracula:"Dracula","solarized-dark":"Solarized Dark","solarized-light":"Solarized Light",taxi:"Taxi",ocean:"Ocean"},P=[["bg","Background","base"],["card-base","Card","base"],["fg","Text","base"],["muted","Muted Text","base"],["border","Border","base"],["accent","Accent","accent"],["accent-strong","Accent Strong","accent"],["ok-bg","OK Background","status"],["ok-fg","OK Text","status"],["bad-bg","Error Bg","status"],["bad-fg","Error Text","status"],["dot-ok","Dot OK","status"],["dot-bad","Dot Error","status"],["uptime","Uptime Bar","status"],["hover","Hover","advanced"],["card-hover","Card Hover","advanced"],["base","Tags/Badges","advanced"],["fg-muted","Dim Text","advanced"],["success","Success","advanced"],["error","Error","advanced"],["warning","Warning","advanced"]],A=document.getElementById("theme");if(!A)return;var D=document.getElementById("theme-label");function R(n){if(h[n])return h[n];var r=safeGetJSON(window.USER_THEMES_KEY,{});return r[n]&&r[n].name||n}function y(){D&&(D.textContent=R(window.getActiveTheme()))}A.addEventListener("click",function(){var n=window.THEMES.slice(),r=window.getActiveTheme(),a=n.indexOf(r),i=n[(a+1)%n.length];window.applyTheme(i),y()}),y();function $(){var n={base:"Base Colors",accent:"Accent",status:"Status",advanced:"Advanced (auto-derived)"},r={};P.forEach(function(i){r[i[2]]||(r[i[2]]=[]),r[i[2]].push(i)});var a="";return Object.keys(n).forEach(function(i){i==="advanced"?(a+='<div id="theme-builder-advanced-toggle" class="theme-builder-advanced-toggle" style="margin:12px 0 4px;cursor:pointer;color:var(--accent);font-size:.85rem;user-select:none;">Show advanced colors &#9660;</div>',a+='<div id="theme-builder-advanced" class="theme-builder-section" style="display:none;">'):a+='<div class="theme-builder-section">',a+='<div class="theme-builder-section-title">'+n[i]+"</div>",(r[i]||[]).forEach(function(c){a+='<div class="theme-builder-row"><span class="theme-builder-label">'+c[1]+'</span><input type="color" class="theme-builder-color" data-prop="'+c[0]+'"'+(i==="advanced"?' data-advanced="1"':"")+' value="#000000" /><span class="theme-builder-hex" data-hex="'+c[0]+'">#000000</span></div>'}),a+="</div>"}),a}function k(){return window.THEMES.map(function(n){return'<option value="'+n+'">'+R(n)+"</option>"}).join("")}var H='<div id="theme-builder-modal" class="weather-modal"><div class="weather-modal-content" style="min-width:420px;max-width:560px;"><h3>Theme Builder</h3><div id="theme-builder-existing" style="margin-bottom:16px;display:none;"><label style="font-size:.85rem;color:var(--muted);margin-right:8px;">Edit:</label><select id="theme-builder-edit-select" style="padding:6px 10px;background:var(--card-bg);color:var(--fg);border:1px solid var(--border);border-radius:6px;font-size:.85rem;margin-right:8px;"><option value="">\u2014 New Theme \u2014</option></select><button id="theme-builder-delete" style="padding:4px 10px;background:color-mix(in srgb,var(--bad-fg) 15%,transparent);border:1px solid var(--bad-fg);color:var(--bad-fg);border-radius:6px;font-size:.8rem;cursor:pointer;">Delete</button></div><div style="margin-bottom:16px;"><label style="font-size:.85rem;color:var(--muted);margin-right:8px;">Name:</label><input type="text" id="theme-builder-name" maxlength="20" placeholder="My Theme" style="padding:6px 10px;background:var(--card-bg);color:var(--fg);border:1px solid var(--border);border-radius:6px;font-size:.85rem;width:140px;" /></div><div style="margin-bottom:16px;display:flex;align-items:center;"><label style="font-size:.85rem;color:var(--muted);margin-right:8px;cursor:pointer;" for="theme-builder-lightbg"><input type="checkbox" id="theme-builder-lightbg" style="margin-right:6px;cursor:pointer;vertical-align:middle;" />Light background (use dark logo)</label></div><div style="margin-bottom:16px;"><label style="font-size:.85rem;color:var(--muted);margin-right:8px;">Start from:</label><select id="theme-builder-start" style="padding:6px 10px;background:var(--card-bg);color:var(--fg);border:1px solid var(--border);border-radius:6px;font-size:.85rem;">'+k()+'</select></div><div class="theme-builder-preview" id="theme-builder-preview"><div class="theme-builder-card" id="theme-preview-card"><div class="preview-title">Sample Card</div><div class="preview-muted">Secondary text preview</div><div class="preview-badges"><span class="preview-badge" id="preview-badge-ok">ON</span><span class="preview-badge" id="preview-badge-bad">OFF</span></div><div class="preview-dots"><span><span class="preview-dot" id="preview-dot-ok"></span> Online</span><span><span class="preview-dot" id="preview-dot-bad"></span> Offline</span></div><button class="preview-btn" id="preview-accent-btn">Accent Button</button></div></div>'+$()+'<div class="weather-modal-buttons"><button id="theme-builder-cancel">Cancel</button><button id="theme-builder-import" style="margin-left:auto;" title="Import theme from JSON file">Import</button><button id="theme-builder-export" title="Export theme as JSON file">Export</button><button id="theme-builder-save" class="btn-accent">Save Theme</button></div></div></div>';injectModal("theme-builder-modal",H);var T=document.getElementById("theme-builder-modal"),z=document.getElementById("theme-builder-start"),C=document.getElementById("theme-builder-name"),M=document.getElementById("theme-builder-edit-select"),b=document.getElementById("theme-builder-existing"),d=document.getElementById("theme-builder-lightbg"),v=T.querySelectorAll(".theme-builder-color"),S=document.getElementById("theme-builder-advanced"),O=document.getElementById("theme-builder-advanced-toggle"),m=document.getElementById("theme-builder-export"),f=!1;O.addEventListener("click",function(){f=!f,S.style.display=f?"":"none",O.innerHTML=f?"Hide advanced colors &#9650;":"Show advanced colors &#9660;"});function B(){var n={};return v.forEach(function(r){n[r.dataset.prop]=r.value}),n["card-bg"]=n["card-base"],n}function w(){var n={};return v.forEach(function(r){r.dataset.advanced||(n[r.dataset.prop]=r.value)}),n["card-bg"]=n["card-base"],d.checked&&(n.lightBg=!0),n}function L(){var n=w(),r=window.deriveExtendedColors?window.deriveExtendedColors(n):{};v.forEach(function(a){if(a.dataset.advanced&&!j[a.dataset.prop]){var i=r[a.dataset.prop]||"#333333";a.value=i;var c=T.querySelector('[data-hex="'+a.dataset.prop+'"]');c&&(c.textContent=i.toUpperCase())}})}function o(n){var r=window.THEME_COLORS[n];r&&(j={},v.forEach(function(a){var i=r[a.dataset.prop]||"#000000";(i.startsWith("rgba")||i.startsWith("color-mix"))&&(i="#333333"),a.value=i;var c=T.querySelector('[data-hex="'+a.dataset.prop+'"]');c&&(c.textContent=i.toUpperCase())}),d.checked=!!r.lightBg,l())}function u(n){var r=safeGetJSON(window.USER_THEMES_KEY,{}),a=r[n];a&&(j={},v.forEach(function(i){var c=a[i.dataset.prop]||"#000000";i.value=c;var I=T.querySelector('[data-hex="'+i.dataset.prop+'"]');I&&(I.textContent=c.toUpperCase()),i.dataset.advanced&&a[i.dataset.prop]&&(j[i.dataset.prop]=!0)}),C.value=a.name||"",d.checked=!!a.lightBg,L(),l())}function l(){var n=B(),r=document.getElementById("theme-builder-preview"),a=document.getElementById("theme-preview-card"),i=a.querySelector(".preview-title"),c=a.querySelector(".preview-muted"),I=document.getElementById("preview-badge-ok"),N=document.getElementById("preview-badge-bad"),U=document.getElementById("preview-dot-ok"),_=document.getElementById("preview-dot-bad"),F=document.getElementById("preview-accent-btn"),q=a.querySelector(".preview-dots");r.style.background=n.bg,a.style.background=n["card-base"],a.style.borderColor=n.border,i.style.color=n.fg,c.style.color=n.muted,I.style.background=n["ok-bg"],I.style.color=n["ok-fg"],N.style.background=n["bad-bg"],N.style.color=n["bad-fg"],U.style.background=n["dot-ok"],_.style.background=n["dot-bad"],q.style.color=n.fg,F.style.background=n.accent,F.style.color=n.bg}function g(n){var r=window.deriveExtendedColors?window.deriveExtendedColors(n):{};window.THEME_PROPS.forEach(function(a){var i=n[a]||r[a];i&&document.documentElement.style.setProperty("--"+a,i)})}v.forEach(function(n){n.addEventListener("input",function(){var r=T.querySelector('[data-hex="'+n.dataset.prop+'"]');r&&(r.textContent=n.value.toUpperCase()),n.dataset.advanced?j[n.dataset.prop]=!0:L(),l(),g(B())})}),d.addEventListener("change",function(){L(),l(),g(B())}),z.addEventListener("change",function(){j={},o(z.value),g(B())});function p(){var n=safeGetJSON(window.USER_THEMES_KEY,{}),r=Object.keys(n);M.innerHTML='<option value="">\u2014 New Theme \u2014</option>',r.forEach(function(a){var i=document.createElement("option");i.value=a,i.textContent=n[a].name||a,M.appendChild(i)}),b.style.display=r.length?"":"none"}function t(){z.innerHTML=k()}M.addEventListener("change",function(){var n=this.value;n?(E=n,u(n),g(B())):(E=null,j={},C.value="",z.value=window.getActiveTheme(),o(z.value)),m.style.display=E?"":"none"});function e(){x=window.getActiveTheme(),E=null,j={},f=!1,S.style.display="none",O.innerHTML="Show advanced colors &#9660;",p(),t();var n=safeGetJSON(window.USER_THEMES_KEY,{});n[x]?(M.value=x,E=x,u(x)):(M.value="",C.value="",z.value=x,o(x)),m.style.display=E?"":"none",T.classList.add("show")}var s=document.getElementById("theme-customize-btn");s&&s.addEventListener("click",function(){e()}),document.getElementById("theme-builder-save").addEventListener("click",function(){var n=B(),r=C.value.trim();if(!r){showNotification("Please enter a theme name","warning",3e3),C.focus();return}var a=safeGetJSON(window.USER_THEMES_KEY,{}),i,c=null;if(E){i=E;var I=window.slugifyThemeName(r,E);if(I!==E){c=E,delete a[E];var N=window.THEMES.indexOf(E);N!==-1&&window.THEMES.splice(N,1),delete window.THEME_COLORS[E],i=I}}else i=window.slugifyThemeName(r);var U={name:r};d.checked&&(U.lightBg=!0),window.THEME_PROPS.forEach(function(F){n[F]&&(U[F]=n[F])}),a[i]=U,safeSet(window.USER_THEMES_KEY,JSON.stringify(a)),window.clearCustomProperties(),window.injectUserThemeStyles(),window.applyTheme(i),T.classList.remove("show"),y();var _={};window.THEME_PROPS.forEach(function(F){n[F]&&(_[F]=n[F])}),c&&secureFetch("/api/v1/themes/"+c,{method:"DELETE"}).catch(function(){}),secureFetch("/api/v1/themes/"+i,{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify({name:r,colors:_,lightBg:d.checked})}).then(function(){showNotification(r+" theme saved","success",3e3)}).catch(function(){showNotification(r+" theme saved locally (server sync failed)","warning",3e3)})}),document.getElementById("theme-builder-cancel").addEventListener("click",function(){T.classList.remove("show"),window.clearCustomProperties(),x&&window.applyTheme(x)}),document.getElementById("theme-builder-delete").addEventListener("click",function(){if(E){var n=safeGetJSON(window.USER_THEMES_KEY,{}),r=n[E]?n[E].name:E;if(confirm('Delete "'+r+'" theme?')){var a=E;delete n[a],safeSet(window.USER_THEMES_KEY,JSON.stringify(n));var i=window.THEMES.indexOf(a);i!==-1&&window.THEMES.splice(i,1),delete window.THEME_COLORS[a],window.clearCustomProperties(),window.injectUserThemeStyles();var c=x&&x!==a?x:"dark";window.applyTheme(c),E=null,T.classList.remove("show"),y(),secureFetch("/api/v1/themes/"+a,{method:"DELETE"}).then(function(){showNotification(r+" theme deleted","success",3e3)}).catch(function(){showNotification(r+" theme deleted locally (server sync failed)","warning",3e3)})}}}),document.getElementById("theme-builder-export").addEventListener("click",function(){if(!E){showNotification("Save the theme first, then export","warning",3e3);return}var n=safeGetJSON(window.USER_THEMES_KEY,{}),r=n[E];if(r){var a={_dashcaddy_theme:!0,version:"1.0",exportDate:new Date().toISOString(),slug:E,name:r.name,lightBg:r.lightBg||!1,colors:{}};window.THEME_PROPS.forEach(function(N){r[N]&&(a.colors[N]=r[N])});var i=new Blob([JSON.stringify(a,null,2)],{type:"application/json"}),c=URL.createObjectURL(i),I=document.createElement("a");I.href=c,I.download=E+"-theme.json",document.body.appendChild(I),I.click(),document.body.removeChild(I),URL.revokeObjectURL(c),showNotification("Theme exported as "+E+"-theme.json","success",3e3)}}),document.getElementById("theme-builder-import").addEventListener("click",function(){var n=document.createElement("input");n.type="file",n.accept=".json",n.onchange=function(r){var a=r.target.files[0];if(a){var i=new FileReader;i.onload=function(c){try{var I=JSON.parse(c.target.result),N,U,_;if(I._dashcaddy_theme&&I.colors)N=I.name||"Imported",U=I.colors,_=I.lightBg||!1;else if(I.name&&(I.bg||I["card-base"]))N=I.name,U={},window.THEME_PROPS.forEach(function(F){I[F]&&(U[F]=I[F])}),_=I.lightBg||!1;else throw new Error("Not a valid DashCaddy theme file");C.value=N,d.checked=!!_,E=null,M.value="",j={},v.forEach(function(F){var q=U[F.dataset.prop]||"#000000";F.value=q;var J=T.querySelector('[data-hex="'+F.dataset.prop+'"]');J&&(J.textContent=q.toUpperCase()),F.dataset.advanced&&U[F.dataset.prop]&&(j[F.dataset.prop]=!0)}),L(),l(),g(B()),m.style.display="none",showNotification('"'+N+'" loaded into builder. Click Save to keep it.',"success",5e3)}catch(F){showNotification("Import failed: "+F.message,"error",5e3)}},i.readAsText(a)}},n.click()}),wireModal(T),T.addEventListener("click",function(n){n.target===T&&(window.clearCustomProperties(),x&&window.applyTheme(x))})})(),(function(){injectModal("license-modal",`<div id="license-modal" class="weather-modal">
     <div class="weather-modal-content" style="min-width: 420px; max-width: 520px;">
       <h3>DashCaddy License</h3>
       <p style="font-size: 0.85rem; color: var(--muted); margin: 0 0 16px;">
@@ -2220,16 +2220,16 @@ This can take ~30-60s\u2026`);try{const{body:v}=await P("/deploy",{method:"POST"
         <button id="license-activate" class="btn-accent">Activate</button>
       </div>
     </div>
-  </div>`);const x=document.getElementById("license-modal"),E=document.getElementById("license-code-input"),R=document.getElementById("license-activate"),h=document.getElementById("license-deactivate"),P=document.getElementById("license-error"),A=document.getElementById("license-success"),D=document.getElementById("license-badge-icon"),j=document.getElementById("license-badge-text"),g=document.getElementById("license-badge"),$=document.getElementById("license-details"),k=document.getElementById("license-feature-list"),M=document.getElementById("license-activate-section");let T=null;function z(){P.style.display="none",A.style.display="none"}function C(B){z(),P.textContent=B,P.style.display="block"}function H(B){z(),A.textContent=B,A.style.display="block"}function b(B){if(T=B,B.active){g.style.background="rgba(46,204,113,0.15)",g.style.color="var(--ok-fg)",D.textContent="\u2605",j.textContent="Premium Active";const o=B.lifetime?"<div>License: <strong>LIFETIME</strong></div>":`<div>Expires: <strong>${new Date(B.expiresAt).toLocaleDateString()}</strong> (${B.daysRemaining} days remaining)</div>`;$.innerHTML=`
+  </div>`);const x=document.getElementById("license-modal"),E=document.getElementById("license-code-input"),j=document.getElementById("license-activate"),h=document.getElementById("license-deactivate"),P=document.getElementById("license-error"),A=document.getElementById("license-success"),D=document.getElementById("license-badge-icon"),R=document.getElementById("license-badge-text"),y=document.getElementById("license-badge"),$=document.getElementById("license-details"),k=document.getElementById("license-feature-list"),H=document.getElementById("license-activate-section");let T=null;function z(){P.style.display="none",A.style.display="none"}function C(B){z(),P.textContent=B,P.style.display="block"}function M(B){z(),A.textContent=B,A.style.display="block"}function b(B){if(T=B,B.active){y.style.background="rgba(46,204,113,0.15)",y.style.color="var(--ok-fg)",D.textContent="\u2605",R.textContent="Premium Active";const o=B.lifetime?"<div>License: <strong>LIFETIME</strong></div>":`<div>Expires: <strong>${new Date(B.expiresAt).toLocaleDateString()}</strong> (${B.daysRemaining} days remaining)</div>`;$.innerHTML=`
         <div>Code: <code style="font-family: monospace;">${B.code||"***"}</code></div>
         ${o}
-      `,M.style.display="none",R.style.display="none",h.style.display=""}else g.style.background="rgba(149,165,166,0.15)",g.style.color="var(--muted)",D.textContent="\u2606",j.textContent=B.expired?"License Expired":"Free Tier",$.innerHTML=B.expired?"<div>Your license has expired. Enter a new code to renew.</div>":"<div>Enter a license code to unlock premium features.</div>",M.style.display="",R.style.display="",h.style.display="none";const w=B.premiumFeatures||{},L=new Set(B.features||[]);k.innerHTML=Object.entries(w).map(([o,p])=>`<div style="display: flex; align-items: center; gap: 8px; padding: 8px 12px; border-radius: 6px; background: var(--card-bg); border: 1px solid var(--border);">
+      `,H.style.display="none",j.style.display="none",h.style.display=""}else y.style.background="rgba(149,165,166,0.15)",y.style.color="var(--muted)",D.textContent="\u2606",R.textContent=B.expired?"License Expired":"Free Tier",$.innerHTML=B.expired?"<div>Your license has expired. Enter a new code to renew.</div>":"<div>Enter a license code to unlock premium features.</div>",H.style.display="",j.style.display="",h.style.display="none";const w=B.premiumFeatures||{},L=new Set(B.features||[]);k.innerHTML=Object.entries(w).map(([o,u])=>`<div style="display: flex; align-items: center; gap: 8px; padding: 8px 12px; border-radius: 6px; background: var(--card-bg); border: 1px solid var(--border);">
         <span style="font-size: 1.1rem;">${L.has(o)?"\u2705":"\u{1F512}"}</span>
         <div>
-          <div style="font-weight: 600; font-size: 0.9rem;">${p.name}</div>
-          <div style="font-size: 0.78rem; color: var(--muted);">${p.description}</div>
+          <div style="font-weight: 600; font-size: 0.9rem;">${u.name}</div>
+          <div style="font-size: 0.78rem; color: var(--muted);">${u.description}</div>
         </div>
-      </div>`).join("")}async function d(){try{const w=await(await fetch("/api/v1/license/status")).json();w.success&&(b(w.license),O(w.license))}catch(B){console.warn("Failed to load license status:",B.message)}}async function v(){const B=E.value.trim();if(!B){C("Please enter a license code.");return}z(),R.disabled=!0,R.textContent="Activating...";try{const L=await(await secureFetch("/api/v1/license/activate",{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify({code:B})})).json();L.success?(H(L.message),E.value="",b(L.license),showNotification("License activated! Premium features unlocked.","success",5e3),O(L.license)):C(L.error||"Activation failed")}catch(w){C("Network error: "+w.message)}finally{R.disabled=!1,R.textContent="Activate"}}async function S(){if(confirm("Deactivate your license? You can reuse the code on another machine.")){h.disabled=!0,h.textContent="Deactivating...";try{const w=await(await secureFetch("/api/v1/license/deactivate",{method:"POST"})).json();w.success?(H(w.message),await d(),showNotification("License deactivated.","info",3e3),O({active:!1})):C(w.error||"Deactivation failed")}catch(B){C("Network error: "+B.message)}finally{h.disabled=!1,h.textContent="Deactivate"}}}function O(B){const w=document.getElementById("license-status-topbar"),L=document.getElementById("license-topbar-icon"),o=document.getElementById("license-topbar-text"),p=document.getElementById("license-topbar-time");if(w)if(w.className="license-status-topbar "+(B.active?"premium":"free"),B.active)if(L.textContent="\u2605",o.textContent="PREMIUM",B.lifetime)p.textContent="\xB7 LIFETIME";else{const l=B.daysRemaining;p.textContent=l!=null?"\xB7 "+l+"d remaining":""}else L.textContent="\u2606",o.textContent=B.expired?"EXPIRED":"FREE TIER",p.textContent=""}function m(){z(),d(),x.classList.add("show")}E.addEventListener("input",function(){let B=this.value.toUpperCase().replace(/[^A-Z0-9-]/g,"");if(B.length>this._prevLength&&(B=B.replace(/-/g,""),B.length>2&&!B.startsWith("DC")&&(B="DC"+B),B.startsWith("DC")&&B.length>2)){const w=["DC"],L=B.substring(2);for(let o=0;o<L.length;o+=5)w.push(L.substring(o,o+5));B=w.join("-")}this._prevLength=B.length,this.value=B}),R.addEventListener("click",v),h.addEventListener("click",S),E.addEventListener("keydown",B=>{B.key==="Enter"&&v()}),wireModal(x,document.getElementById("license-cancel"));const f=document.getElementById("license-status-topbar");f&&f.addEventListener("click",()=>window.openLicenseModal&&window.openLicenseModal()),window.openLicenseModal=m,window.checkPremiumFeature=async function(B){try{return(await(await fetch(`/api/v1/license/feature/${B}`)).json()).available}catch{return!1}},d().then(B=>{T&&O(T)})})(),(function(){"use strict";if(window.__dc_058_share_modal_loaded)return;window.__dc_058_share_modal_loaded=!0;const x=[{ms:3600*1e3,label:"1 hour"},{ms:1440*60*1e3,label:"24 hours"},{ms:10080*60*1e3,label:"7 days"}];injectModal("share-modal",`
+      </div>`).join("")}async function d(){try{const w=await(await fetch("/api/v1/license/status")).json();w.success&&(b(w.license),O(w.license))}catch(B){console.warn("Failed to load license status:",B.message)}}async function v(){const B=E.value.trim();if(!B){C("Please enter a license code.");return}z(),j.disabled=!0,j.textContent="Activating...";try{const L=await(await secureFetch("/api/v1/license/activate",{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify({code:B})})).json();L.success?(M(L.message),E.value="",b(L.license),showNotification("License activated! Premium features unlocked.","success",5e3),O(L.license)):C(L.error||"Activation failed")}catch(w){C("Network error: "+w.message)}finally{j.disabled=!1,j.textContent="Activate"}}async function S(){if(confirm("Deactivate your license? You can reuse the code on another machine.")){h.disabled=!0,h.textContent="Deactivating...";try{const w=await(await secureFetch("/api/v1/license/deactivate",{method:"POST"})).json();w.success?(M(w.message),await d(),showNotification("License deactivated.","info",3e3),O({active:!1})):C(w.error||"Deactivation failed")}catch(B){C("Network error: "+B.message)}finally{h.disabled=!1,h.textContent="Deactivate"}}}function O(B){const w=document.getElementById("license-status-topbar"),L=document.getElementById("license-topbar-icon"),o=document.getElementById("license-topbar-text"),u=document.getElementById("license-topbar-time");if(w)if(w.className="license-status-topbar "+(B.active?"premium":"free"),B.active)if(L.textContent="\u2605",o.textContent="PREMIUM",B.lifetime)u.textContent="\xB7 LIFETIME";else{const l=B.daysRemaining;u.textContent=l!=null?"\xB7 "+l+"d remaining":""}else L.textContent="\u2606",o.textContent=B.expired?"EXPIRED":"FREE TIER",u.textContent=""}function m(){z(),d(),x.classList.add("show")}E.addEventListener("input",function(){let B=this.value.toUpperCase().replace(/[^A-Z0-9-]/g,"");if(B.length>this._prevLength&&(B=B.replace(/-/g,""),B.length>2&&!B.startsWith("DC")&&(B="DC"+B),B.startsWith("DC")&&B.length>2)){const w=["DC"],L=B.substring(2);for(let o=0;o<L.length;o+=5)w.push(L.substring(o,o+5));B=w.join("-")}this._prevLength=B.length,this.value=B}),j.addEventListener("click",v),h.addEventListener("click",S),E.addEventListener("keydown",B=>{B.key==="Enter"&&v()}),wireModal(x,document.getElementById("license-cancel"));const f=document.getElementById("license-status-topbar");f&&f.addEventListener("click",()=>window.openLicenseModal&&window.openLicenseModal()),window.openLicenseModal=m,window.checkPremiumFeature=async function(B){try{return(await(await fetch(`/api/v1/license/feature/${B}`)).json()).available}catch{return!1}},d().then(B=>{T&&O(T)})})(),(function(){"use strict";if(window.__dc_058_share_modal_loaded)return;window.__dc_058_share_modal_loaded=!0;const x=[{ms:3600*1e3,label:"1 hour"},{ms:1440*60*1e3,label:"24 hours"},{ms:10080*60*1e3,label:"7 days"}];injectModal("share-modal",`
     <div id="share-modal" class="weather-modal" role="dialog" aria-labelledby="share-modal-title">
       <div class="weather-modal-content" style="min-width: 460px; max-width: 580px;">
         <h3 id="share-modal-title">Share <span id="share-modal-service-name">\u2026</span></h3>
@@ -2298,7 +2298,7 @@ This can take ~30-60s\u2026`);try{const{body:v}=await P("/deploy",{method:"POST"
         </div>
       </div>
     </div>
-  `);const E=document.getElementById("share-modal"),R=document.getElementById("share-modal-service-name"),h=document.getElementById("share-issued"),P=document.getElementById("share-issued-url"),A=document.getElementById("share-issued-copy"),D=document.getElementById("share-issued-meta"),j=document.getElementById("share-error"),g=document.getElementById("share-success"),$=document.getElementById("share-outstanding-list"),k=document.getElementById("share-cancel"),M=document.getElementById("share-public-create"),T=document.getElementById("share-ts-create"),z=document.getElementById("share-ts-email"),C=document.getElementById("share-public-ttl");let H=null,b="public";function d(){j.style.display="none",g.style.display="none",h.style.display="none"}function v(t){g.style.display="none",h.style.display="none",j.textContent=t,j.style.display="block"}function S(t){j.style.display="none",g.textContent=t,g.style.display="block"}function O(){return window.location.origin}function m(t){return t.startsWith("http")?t:O()+t}function f(t){if(!t)return"";const e=new Date(t);return Number.isNaN(e.getTime())?"":e.toLocaleString()}function B(t){if(t<=0)return"expired";const e=Math.floor(t/36e5);if(e>=24)return`${Math.floor(e/24)}d ${e%24}h left`;const s=Math.floor(t%36e5/6e4);return`${e}h ${s}m left`}function w(t){b=t,d(),E.querySelectorAll(".share-tab").forEach(e=>{const s=e.dataset.tab===t;e.classList.toggle("active",s),e.style.borderBottomColor=s?"var(--accent)":"transparent",e.style.color=s?"var(--fg)":"var(--muted)",e.style.fontWeight=s?"600":"400"}),E.querySelectorAll(".share-tab-panel").forEach(e=>{e.style.display=e.dataset.panel===t?"":"none"})}async function L(){$.innerHTML='<span style="color: var(--muted);">Loading\u2026</span>';try{const t=await fetch("/api/v1/share",{credentials:"same-origin"});if(!t.ok){$.innerHTML='<span style="color: var(--muted);">No shares listed.</span>';return}const e=await t.json(),n=(e&&e.data||[]).filter(r=>r.serviceId===H.id);if(n.length===0){$.innerHTML='<span style="color: var(--muted);">No outstanding shares for this service.</span>';return}$.innerHTML=n.map(r=>{const a=r.expiresAt?B(new Date(r.expiresAt).getTime()-Date.now()):"";return`
+  `);const E=document.getElementById("share-modal"),j=document.getElementById("share-modal-service-name"),h=document.getElementById("share-issued"),P=document.getElementById("share-issued-url"),A=document.getElementById("share-issued-copy"),D=document.getElementById("share-issued-meta"),R=document.getElementById("share-error"),y=document.getElementById("share-success"),$=document.getElementById("share-outstanding-list"),k=document.getElementById("share-cancel"),H=document.getElementById("share-public-create"),T=document.getElementById("share-ts-create"),z=document.getElementById("share-ts-email"),C=document.getElementById("share-public-ttl");let M=null,b="public";function d(){R.style.display="none",y.style.display="none",h.style.display="none"}function v(t){y.style.display="none",h.style.display="none",R.textContent=t,R.style.display="block"}function S(t){R.style.display="none",y.textContent=t,y.style.display="block"}function O(){return window.location.origin}function m(t){return t.startsWith("http")?t:O()+t}function f(t){if(!t)return"";const e=new Date(t);return Number.isNaN(e.getTime())?"":e.toLocaleString()}function B(t){if(t<=0)return"expired";const e=Math.floor(t/36e5);if(e>=24)return`${Math.floor(e/24)}d ${e%24}h left`;const s=Math.floor(t%36e5/6e4);return`${e}h ${s}m left`}function w(t){b=t,d(),E.querySelectorAll(".share-tab").forEach(e=>{const s=e.dataset.tab===t;e.classList.toggle("active",s),e.style.borderBottomColor=s?"var(--accent)":"transparent",e.style.color=s?"var(--fg)":"var(--muted)",e.style.fontWeight=s?"600":"400"}),E.querySelectorAll(".share-tab-panel").forEach(e=>{e.style.display=e.dataset.panel===t?"":"none"})}async function L(){$.innerHTML='<span style="color: var(--muted);">Loading\u2026</span>';try{const t=await fetch("/api/v1/share",{credentials:"same-origin"});if(!t.ok){$.innerHTML='<span style="color: var(--muted);">No shares listed.</span>';return}const e=await t.json(),n=(e&&e.data||[]).filter(r=>r.serviceId===M.id);if(n.length===0){$.innerHTML='<span style="color: var(--muted);">No outstanding shares for this service.</span>';return}$.innerHTML=n.map(r=>{const a=r.expiresAt?B(new Date(r.expiresAt).getTime()-Date.now()):"";return`
           <div class="share-row" data-share-id="${escapeHtml(r.id)}"
             style="display: flex; align-items: center; gap: 8px; padding: 6px 0; border-bottom: 1px dashed var(--border);">
             <span style="flex: 1;">
@@ -2310,5 +2310,5 @@ This can take ~30-60s\u2026`);try{const{body:v}=await P("/deploy",{method:"POST"
               Revoke
             </button>
           </div>
-        `}).join(""),$.querySelectorAll(".share-revoke").forEach(r=>{r.addEventListener("click",()=>o(r.dataset.shareId))})}catch{$.innerHTML='<span style="color: var(--muted);">Could not load outstanding shares.</span>'}}async function o(t){try{const e=await fetch(`/api/v1/share/${encodeURIComponent(t)}`,{method:"DELETE",credentials:"same-origin"});if(!e.ok){const s=await e.json().catch(()=>({}));v(s&&s.error||`Revoke failed (HTTP ${e.status}).`);return}S("Share revoked."),L()}catch{v("Network error while revoking.")}}async function p(){if(!H)return;d(),M.disabled=!0;const t=M.textContent;M.textContent="Creating\u2026";try{const e=parseInt(C.value,10),s=await fetch("/api/v1/share",{method:"POST",credentials:"same-origin",headers:{"Content-Type":"application/json"},body:JSON.stringify({serviceId:H.id,ttlMs:e})}),n=await s.json().catch(()=>({}));if(!s.ok||!n.success){y(s.status,n);return}const r=n.data.urlPath;P.value=m(r),D.textContent=`Public link \xB7 expires ${f(n.data.expiresAt)}`,h.style.display="block",S("Share link created."),L()}catch{v("Network error while creating share.")}finally{M.disabled=!1,M.textContent=t}}async function l(){if(!H)return;const t=(z.value||"").trim();if(!t||!t.includes("@")){v("A valid recipient email is required.");return}d(),T.disabled=!0;const e=T.textContent;T.textContent="Creating\u2026";try{const s=await fetch("/api/v1/share/tailscale",{method:"POST",credentials:"same-origin",headers:{"Content-Type":"application/json"},body:JSON.stringify({serviceId:H.id,email:t})}),n=await s.json().catch(()=>({}));if(!s.ok||!n.success){y(s.status,n);return}const r=n.data&&n.data.urlPath;r?(P.value=m(r),D.textContent=`Tailscale invite \xB7 emailed to ${t} (or use this URL manually if delivery failed).`):(P.value="",D.textContent=`Tailscale invite sent to ${t}.`),h.style.display="block",S("Tailscale invite created."),z.value="",L()}catch{v("Network error while creating Tailscale invite.")}finally{T.disabled=!1,T.textContent=e}}function y(t,e){const s=e&&e.error||"";if(t===402){v("Share is a Pro feature. Activate a license to unlock.");return}if(t===400&&/tailscale/i.test(s)){v("Tailscale is not configured on this host. Set up Tailscale in the dashboard first.");return}if(t===403){v("You do not have permission to share services.");return}if(t===404){v("Service not found. It may have been deleted.");return}v(s||`Request failed (HTTP ${t}).`)}function u(t){!t||!t.id||(H={id:t.id,name:t.name||t.id},R.textContent=H.name,d(),w("public"),z.value="",C.value=String(x[1].ms),E.classList.add("show"),L())}E.querySelectorAll(".share-tab").forEach(t=>{t.addEventListener("click",()=>w(t.dataset.tab))}),M.addEventListener("click",p),T.addEventListener("click",l),k.addEventListener("click",()=>E.classList.remove("show")),wireModal(E,k),A.addEventListener("click",async()=>{const t=P.value;if(t)try{navigator.clipboard&&navigator.clipboard.writeText?await navigator.clipboard.writeText(t):(P.select(),document.execCommand("copy"));const e=A.textContent;A.textContent="Copied!",setTimeout(()=>{A.textContent=e},1200)}catch{v("Could not copy to clipboard. Select the URL manually.")}}),window.openShareModal=u})();
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["<stdin>"],
  "sourcesContent": ["// Logo Customization System\n(function() {\n  // Inject modal HTML\n  injectModal('logo-modal', `<div id=\"logo-modal\" class=\"weather-modal\">\n    <div class=\"weather-modal-content\" style=\"min-width: 400px; max-width: 520px;\">\n      <h3>Dashboard Settings</h3>\n      <p style=\"font-size: 0.85rem; color: var(--muted); margin: 0 0 16px;\">\n        Customize your dashboard's appearance and system preferences.\n      </p>\n\n      <div class=\"mb-16\">\n        <label for=\"dashboard-title\" class=\"form-label-bold\">Dashboard Title:</label>\n        <input type=\"text\" id=\"dashboard-title\" placeholder=\"DashCaddy\" maxlength=\"50\" style=\"width: 100%; padding: 10px 12px; border: 1px solid var(--border); border-radius: 4px; background: var(--card-bg); color: var(--fg); font-size: 1rem;\" />\n        <p class=\"tiny-hint\">Shown in browser tab and header (max 50 characters)</p>\n      </div>\n\n      <hr class=\"hr-divider\" />\n\n      <div class=\"mb-16\">\n        <label class=\"form-label-bold\">Logo:</label>\n        <p class=\"tiny-hint\" style=\"margin-top: 2px;\">Separate logos for dark and light themes, or use the same for both.</p>\n      </div>\n\n      <div style=\"display: flex; gap: 12px; margin-bottom: 12px;\">\n        <div style=\"flex: 1; text-align: center; padding: 16px 10px; border-radius: 8px; background: #1a1a2e; border: 1px solid rgba(255,255,255,.1);\">\n          <img id=\"logo-preview-dark\" src=\"/assets/dashcaddy-logo-dark.png\" alt=\"Dark theme logo\" style=\"max-height: 60px; max-width: 100%;\" />\n          <p style=\"font-size: 0.65rem; color: #9aa6bf; margin-top: 6px;\">Dark themes</p>\n        </div>\n        <div style=\"flex: 1; text-align: center; padding: 16px 10px; border-radius: 8px; background: #f0f0f0; border: 1px solid rgba(0,0,0,.1);\">\n          <img id=\"logo-preview-light\" src=\"/assets/dashcaddy-logo-light.png\" alt=\"Light theme logo\" style=\"max-height: 60px; max-width: 100%;\" />\n          <p style=\"font-size: 0.65rem; color: #5f6b7a; margin-top: 6px;\">Light themes</p>\n        </div>\n      </div>\n      <p id=\"logo-status\" style=\"font-size: 0.75rem; color: var(--muted); margin-bottom: 12px; text-align: center;\">Using default logos</p>\n\n      <div class=\"mb-16\">\n        <label style=\"display: flex; align-items: center; gap: 8px; font-size: 0.82rem; cursor: pointer; user-select: none;\">\n          <input type=\"checkbox\" id=\"logo-same-both\" /> Use same logo for both\n        </label>\n      </div>\n\n      <div id=\"logo-dual-uploads\" class=\"mb-16\" style=\"display: flex; gap: 12px;\">\n        <div style=\"flex: 1;\">\n          <label for=\"logo-upload-dark\" style=\"display: block; margin-bottom: 6px; font-size: 0.8rem;\">Dark theme logo:</label>\n          <input type=\"file\" id=\"logo-upload-dark\" accept=\"image/*\" class=\"input-card-alt\" style=\"font-size: 0.75rem;\" />\n        </div>\n        <div style=\"flex: 1;\">\n          <label for=\"logo-upload-light\" style=\"display: block; margin-bottom: 6px; font-size: 0.8rem;\">Light theme logo:</label>\n          <input type=\"file\" id=\"logo-upload-light\" accept=\"image/*\" class=\"input-card-alt\" style=\"font-size: 0.75rem;\" />\n        </div>\n      </div>\n\n      <div id=\"logo-single-upload\" class=\"mb-16\" style=\"display: none;\">\n        <label for=\"logo-upload-single\" style=\"display: block; margin-bottom: 6px; font-size: 0.8rem;\">Upload logo:</label>\n        <input type=\"file\" id=\"logo-upload-single\" accept=\"image/*\" class=\"input-card-alt\" />\n        <p class=\"tiny-hint\">This logo will be used on all themes</p>\n      </div>\n\n      <div class=\"mb-16\">\n        <label style=\"display: block; margin-bottom: 8px;\">Logo Position:</label>\n        <div id=\"logo-position-btns\" class=\"flex-row-gap\">\n          <button type=\"button\" data-pos=\"left\" class=\"logo-pos-btn btn-option\">Left</button>\n          <button type=\"button\" data-pos=\"center\" class=\"logo-pos-btn btn-option\">Center</button>\n          <button type=\"button\" data-pos=\"right\" class=\"logo-pos-btn btn-option\">Right</button>\n        </div>\n      </div>\n\n      <hr class=\"hr-divider\" />\n\n      <div class=\"mb-16\">\n        <label class=\"form-label-bold\">Favicon (Browser Tab Icon):</label>\n        <div id=\"favicon-preview-container\" style=\"display: flex; align-items: center; gap: 12px; margin-bottom: 8px; padding: 12px; border-radius: 6px; background: var(--card-bg);\">\n          <img id=\"favicon-preview\" src=\"/assets/dashcaddy-favicon.ico\" alt=\"Current favicon\" style=\"width: 32px; height: 32px; image-rendering: pixelated;\" onerror=\"this.src='data:image/svg+xml,<svg xmlns=%22http://www.w3.org/2000/svg%22 viewBox=%220 0 32 32%22><rect fill=%22%23667%22 width=%2232%22 height=%2232%22 rx=%224%22/></svg>'\" />\n          <span id=\"favicon-status\" class=\"text-tiny-muted\">Using DashCaddy favicon</span>\n        </div>\n        <input type=\"file\" id=\"favicon-upload\" accept=\"image/png,image/svg+xml\" class=\"input-card-alt\" />\n        <p class=\"tiny-hint\">Upload PNG or SVG - automatically converted to ICO</p>\n      </div>\n\n      <hr class=\"hr-divider\" />\n\n      <div class=\"mb-16\">\n        <label for=\"settings-timezone\" class=\"form-label-bold\">Timezone:</label>\n        <select id=\"settings-timezone\" style=\"width: 100%; padding: 10px 12px; border: 1px solid var(--border); border-radius: 4px; background: var(--card-bg); color: var(--fg); font-size: 1rem;\">\n          <!-- Populated by JS with IANA timezones -->\n        </select>\n        <p class=\"tiny-hint\">Used by all deployed containers. Changes apply to new deployments.</p>\n      </div>\n\n      <div class=\"weather-modal-buttons\">\n        <button id=\"logo-reset\" style=\"background: color-mix(in srgb, #ef4444 20%, transparent); border-color: #ef4444; color: #ef4444;\">Reset to Default</button>\n        <button id=\"logo-cancel\">Cancel</button>\n        <button id=\"logo-save\" class=\"btn-accent\">Save</button>\n      </div>\n    </div>\n  </div>`);\n\n  const logoModal = document.getElementById('logo-modal');\n  const previewDark = document.getElementById('logo-preview-dark');\n  const previewLight = document.getElementById('logo-preview-light');\n  const logoStatus = document.getElementById('logo-status');\n  const sameBothCheckbox = document.getElementById('logo-same-both');\n  const dualUploads = document.getElementById('logo-dual-uploads');\n  const singleUpload = document.getElementById('logo-single-upload');\n  const uploadDark = document.getElementById('logo-upload-dark');\n  const uploadLight = document.getElementById('logo-upload-light');\n  const uploadSingle = document.getElementById('logo-upload-single');\n  const brandLogoDark = document.querySelector('#brand .brand-logo-dark');\n  const brandLogoLight = document.querySelector('#brand .brand-logo-light');\n  const topRow = document.querySelector('.top-row');\n  const dashboardTitleInput = document.getElementById('dashboard-title');\n  const DEFAULT_TITLE = DC.NAME;\n\n  let pendingDarkData = null;\n  let pendingLightData = null;\n  let pendingSingleData = null;\n  let currentPosition = 'left';\n  let currentTitle = DEFAULT_TITLE;\n\n  // Toggle between dual and single upload mode\n  sameBothCheckbox?.addEventListener('change', () => {\n    if (sameBothCheckbox.checked) {\n      dualUploads.style.display = 'none';\n      singleUpload.style.display = '';\n      // Clear individual pending data\n      pendingDarkData = null;\n      pendingLightData = null;\n    } else {\n      dualUploads.style.display = 'flex';\n      singleUpload.style.display = 'none';\n      pendingSingleData = null;\n    }\n  });\n\n  // Read file as data URL helper\n  function readFileAsDataURL(file, callback) {\n    if (!file || !file.type.startsWith('image/')) {\n      showNotification('Please select an image file', 'warning');\n      return;\n    }\n    const reader = new FileReader();\n    reader.onload = (e) => callback(e.target.result);\n    reader.readAsDataURL(file);\n  }\n\n  // Upload handlers\n  uploadDark?.addEventListener('change', (e) => {\n    readFileAsDataURL(e.target.files[0], (data) => {\n      pendingDarkData = data;\n      previewDark.src = data;\n      logoStatus.textContent = 'New dark logo ready to save';\n    });\n  });\n\n  uploadLight?.addEventListener('change', (e) => {\n    readFileAsDataURL(e.target.files[0], (data) => {\n      pendingLightData = data;\n      previewLight.src = data;\n      logoStatus.textContent = 'New light logo ready to save';\n    });\n  });\n\n  uploadSingle?.addEventListener('change', (e) => {\n    readFileAsDataURL(e.target.files[0], (data) => {\n      pendingSingleData = data;\n      previewDark.src = data;\n      previewLight.src = data;\n      logoStatus.textContent = 'New logo ready to save (both themes)';\n    });\n  });\n\n  // Apply logo position\n  function applyLogoPosition(pos) {\n    topRow.setAttribute('data-logo-pos', pos);\n    document.querySelectorAll('.logo-pos-btn').forEach(btn => {\n      btn.style.background = btn.dataset.pos === pos ? 'var(--accent)' : 'var(--card-bg)';\n      btn.style.color = btn.dataset.pos === pos ? 'white' : 'var(--fg)';\n    });\n  }\n\n  // Apply dashboard title\n  function applyDashboardTitle(title) {\n    currentTitle = title || DEFAULT_TITLE;\n    document.title = currentTitle;\n    const headerTitle = document.querySelector('.dashboard-title');\n    if (headerTitle) headerTitle.textContent = currentTitle;\n  }\n\n  // Load custom logo, position, and title on startup\n  async function loadCustomLogo() {\n    try {\n      const response = await fetch('/api/v1/logo');\n      if (response.ok) {\n        const data = await response.json();\n        // Apply dark/light variants\n        if (data.customLogoDark) {\n          brandLogoDark.src = data.customLogoDark;\n          previewDark.src = data.customLogoDark;\n        }\n        if (data.customLogoLight) {\n          brandLogoLight.src = data.customLogoLight;\n          previewLight.src = data.customLogoLight;\n        }\n        // Legacy single-logo fallback\n        if (!data.customLogoDark && !data.customLogoLight && data.customLogo) {\n          brandLogoDark.src = data.customLogo;\n          brandLogoLight.src = data.customLogo;\n          previewDark.src = data.customLogo;\n          previewLight.src = data.customLogo;\n        }\n        if (!data.isDefault) {\n          logoStatus.textContent = 'Using custom logo';\n        }\n        if (data.position) {\n          currentPosition = data.position;\n          applyLogoPosition(data.position);\n        }\n        if (data.dashboardTitle) {\n          applyDashboardTitle(data.dashboardTitle);\n        }\n      }\n    } catch (error) {\n      console.warn('Could not load custom logo:', error.message);\n    }\n  }\n\n  // Position button handlers\n  document.querySelectorAll('.logo-pos-btn').forEach(btn => {\n    btn.addEventListener('click', () => {\n      currentPosition = btn.dataset.pos;\n      applyLogoPosition(currentPosition);\n    });\n  });\n\n  // Open logo modal on brand click\n  document.getElementById('brand')?.addEventListener('click', () => {\n    pendingDarkData = null;\n    pendingLightData = null;\n    pendingSingleData = null;\n    if (uploadDark) uploadDark.value = '';\n    if (uploadLight) uploadLight.value = '';\n    if (uploadSingle) uploadSingle.value = '';\n    // Reset checkbox to dual mode\n    if (sameBothCheckbox) sameBothCheckbox.checked = false;\n    dualUploads.style.display = 'flex';\n    singleUpload.style.display = 'none';\n    // Reset previews to current header logos\n    previewDark.src = brandLogoDark.src;\n    previewLight.src = brandLogoLight.src;\n    const isCustom = brandLogoDark.src.includes('custom-logo') || brandLogoLight.src.includes('custom-logo');\n    logoStatus.textContent = isCustom ? 'Using custom logo' : 'Using default logos';\n    applyLogoPosition(currentPosition);\n    dashboardTitleInput.value = currentTitle;\n    logoModal.classList.add('show');\n  });\n\n  // Save logo, position, and title\n  document.getElementById('logo-save')?.addEventListener('click', async () => {\n    try {\n      const newTitle = dashboardTitleInput.value.trim() || DEFAULT_TITLE;\n      const payload = {\n        position: currentPosition,\n        dashboardTitle: newTitle\n      };\n\n      // Determine which logo data to send\n      if (sameBothCheckbox?.checked && pendingSingleData) {\n        // Single logo for both variants\n        payload.dataDark = pendingSingleData;\n        payload.dataLight = pendingSingleData;\n      } else {\n        if (pendingDarkData) payload.dataDark = pendingDarkData;\n        if (pendingLightData) payload.dataLight = pendingLightData;\n      }\n\n      const response = await secureFetch('/api/v1/logo', {\n        method: 'POST',\n        headers: { 'Content-Type': 'application/json' },\n        body: JSON.stringify(payload)\n      });\n\n      if (response.ok) {\n        const data = await response.json();\n        const t = '?t=' + Date.now();\n        if (data.pathDark) {\n          brandLogoDark.src = data.pathDark + t;\n          previewDark.src = data.pathDark + t;\n        }\n        if (data.pathLight) {\n          brandLogoLight.src = data.pathLight + t;\n          previewLight.src = data.pathLight + t;\n        }\n        applyLogoPosition(currentPosition);\n        applyDashboardTitle(newTitle);\n        logoModal.classList.remove('show');\n      } else {\n        const error = await response.json();\n        showNotification('Failed to save: ' + error.error, 'error');\n      }\n    } catch (error) {\n      showNotification('Error saving: ' + error.message, 'error');\n    }\n  });\n\n  // Reset all branding to defaults\n  document.getElementById('logo-reset')?.addEventListener('click', async () => {\n    if (!confirm('Reset all branding to DashCaddy defaults?\\n\\nThis will reset the logo, favicon, title, and position.')) return;\n\n    try {\n      const logoResponse = await secureFetch('/api/v1/logo', { method: 'DELETE' });\n      if (logoResponse.ok) {\n        brandLogoDark.src = '/assets/dashcaddy-logo-dark.png';\n        brandLogoLight.src = '/assets/dashcaddy-logo-light.png';\n        previewDark.src = '/assets/dashcaddy-logo-dark.png';\n        previewLight.src = '/assets/dashcaddy-logo-light.png';\n        logoStatus.textContent = 'Using default logos';\n        pendingDarkData = null;\n        pendingLightData = null;\n        pendingSingleData = null;\n        dashboardTitleInput.value = DEFAULT_TITLE;\n        applyDashboardTitle(DEFAULT_TITLE);\n        currentPosition = 'left';\n        applyLogoPosition('left');\n      }\n\n      const faviconResponse = await secureFetch('/api/v1/favicon', { method: 'DELETE' });\n      if (faviconResponse.ok) {\n        const faviconLink = document.querySelector('link[rel=\"icon\"]');\n        const faviconPreview = document.getElementById('favicon-preview');\n        const faviconStatus = document.getElementById('favicon-status');\n        if (faviconLink) faviconLink.href = '/assets/dashcaddy-favicon.ico?t=' + Date.now();\n        if (faviconPreview) faviconPreview.src = '/assets/dashcaddy-favicon.ico?t=' + Date.now();\n        if (faviconStatus) faviconStatus.textContent = 'Using DashCaddy favicon';\n        pendingFaviconData = null;\n      }\n    } catch (error) {\n      showNotification('Error resetting branding: ' + error.message, 'error');\n    }\n  });\n\n  wireModal(logoModal, document.getElementById('logo-cancel'));\n\n  // ===== FAVICON HANDLING =====\n  const faviconPreview = document.getElementById('favicon-preview');\n  const faviconStatus = document.getElementById('favicon-status');\n  const faviconUpload = document.getElementById('favicon-upload');\n  const faviconLink = document.querySelector('link[rel=\"icon\"]') || document.createElement('link');\n  let pendingFaviconData = null;\n\n  if (!document.querySelector('link[rel=\"icon\"]')) {\n    faviconLink.rel = 'icon';\n    faviconLink.href = '/assets/dashcaddy-favicon.ico';\n    document.head.appendChild(faviconLink);\n  }\n\n  async function loadCustomFavicon() {\n    try {\n      const response = await fetch('/api/v1/favicon');\n      if (response.ok) {\n        const data = await response.json();\n        if (data.customFavicon) {\n          faviconLink.href = data.customFavicon + '?t=' + Date.now();\n          faviconPreview.src = data.customFavicon + '?t=' + Date.now();\n          faviconStatus.textContent = 'Using custom favicon';\n        }\n      }\n    } catch (error) {\n      console.warn('Could not load custom favicon:', error.message);\n    }\n  }\n\n  faviconUpload?.addEventListener('change', (e) => {\n    const file = e.target.files[0];\n    if (!file) return;\n    if (!file.type.match(/^image\\/(png|svg\\+xml)$/)) {\n      showNotification('Please select a PNG or SVG file', 'warning');\n      faviconUpload.value = '';\n      return;\n    }\n    const reader = new FileReader();\n    reader.onload = (event) => {\n      pendingFaviconData = event.target.result;\n      faviconPreview.src = pendingFaviconData;\n      faviconStatus.textContent = 'New favicon ready to save';\n    };\n    reader.readAsDataURL(file);\n  });\n\n  // Save favicon alongside logo save\n  document.getElementById('logo-save')?.addEventListener('click', async () => {\n    if (pendingFaviconData) {\n      try {\n        const response = await secureFetch('/api/v1/favicon', {\n          method: 'POST',\n          headers: { 'Content-Type': 'application/json' },\n          body: JSON.stringify({ data: pendingFaviconData })\n        });\n        if (response.ok) {\n          const data = await response.json();\n          faviconLink.href = data.path + '?t=' + Date.now();\n          faviconPreview.src = data.path + '?t=' + Date.now();\n          faviconStatus.textContent = 'Using custom favicon';\n          pendingFaviconData = null;\n        } else {\n          const error = await response.json();\n          showNotification('Failed to save favicon: ' + error.error, 'error');\n        }\n      } catch (error) {\n        showNotification('Error saving favicon: ' + error.message, 'error');\n      }\n    }\n  });\n\n  loadCustomFavicon();\n  loadCustomLogo();\n\n  // ===== TIMEZONE SETTING =====\n  const settingsTzSelect = document.getElementById('settings-timezone');\n  if (settingsTzSelect) {\n    const observer = new MutationObserver(() => {\n      if (logoModal.classList.contains('show') && settingsTzSelect.options.length === 0) {\n        (async () => {\n          let currentTz;\n          try {\n            const res = await fetch('/api/v1/config');\n            if (res.ok) { const cfg = await res.json(); currentTz = cfg.timezone; }\n          } catch (e) { /* ignore */ }\n          window.populateTimezoneSelect(settingsTzSelect, currentTz);\n        })();\n      }\n    });\n    observer.observe(logoModal, { attributes: true, attributeFilter: ['class'] });\n\n    document.getElementById('logo-save')?.addEventListener('click', async () => {\n      const tz = settingsTzSelect.value;\n      if (!tz) return;\n      try {\n        const res = await fetch('/api/v1/config');\n        if (!res.ok) return;\n        const cfg = await res.json();\n        cfg.timezone = tz;\n        cfg.updatedAt = new Date().toISOString();\n        await secureFetch('/api/v1/config', {\n          method: 'POST',\n          headers: { 'Content-Type': 'application/json' },\n          body: JSON.stringify(cfg)\n        });\n      } catch (e) {\n        console.warn('Failed to save timezone:', e.message);\n      }\n    });\n  }\n})();\n;\n// Shared timezone utility \u2014 used by setup wizard and settings modal\n// errorHandler is declared globally in globals.js (core.js bundle); reusing it\n// here so we don't get \"redeclaration of const errorHandler\" at script scope.\n\nwindow.populateTimezoneSelect = function(selectEl, selectedTz) {\n  const timezones = Intl.supportedValuesOf('timeZone');\n  const detected = selectedTz || Intl.DateTimeFormat().resolvedOptions().timeZone || 'UTC';\n  selectEl.innerHTML = '';\n  for (const tz of timezones) {\n    const opt = document.createElement('option');\n    opt.value = tz;\n    opt.textContent = tz.replace(/_/g, ' ');\n    if (tz === detected) opt.selected = true;\n    selectEl.appendChild(opt);\n  }\n};\n\n// Setup Wizard System - Server-side config storage\n(function () {\n  let currentConfigType = 'homelab';\n  let serverConfig = null;\n\n  // Check server for existing config on page load\n  async function checkServerConfig() {\n    try {\n      const response = await fetch('/api/v1/config');\n      if (response.ok) {\n        serverConfig = await response.json();\n        if (serverConfig && serverConfig.setupComplete) {\n          // Config exists on server - don't show wizard\n          document.getElementById('setup-wizard').style.display = 'none';\n          return true;\n        }\n      }\n    } catch (error) {\n      console.warn('Could not fetch server config, checking localStorage fallback:', error.message);\n    }\n\n    // Fallback: check localStorage for backwards compatibility\n    const localSetup = safeGet('dashcaddy-setup');\n    if (localSetup) {\n      document.getElementById('setup-wizard').style.display = 'none';\n      return true;\n    }\n\n    // No config found - show wizard\n    document.getElementById('setup-wizard').style.display = 'flex';\n    return false;\n  }\n\n  // Initialize on page load\n  checkServerConfig();\n\n  // Populate timezone dropdown with auto-detection\n  const setupTzSelect = document.getElementById('setup-timezone');\n  if (setupTzSelect) window.populateTimezoneSelect(setupTzSelect);\n\n  // Step navigation\n  function showStep(stepId) {\n    document.querySelectorAll('.setup-step').forEach(step => {\n      step.style.display = 'none';\n    });\n    const targetStep = document.getElementById(stepId);\n    if (targetStep) {\n      targetStep.style.display = 'block';\n    }\n  }\n\n  // Show summary\n  function showSummary() {\n    const summaryContent = document.getElementById('setup-summary-content');\n    if (!summaryContent) return;\n\n    let html = '<div style=\"display: grid; gap: 20px;\">';\n\n    if (currentConfigType === 'homelab') {\n      const tld = document.getElementById('setup-tld')?.value?.trim() || '.home';\n      const caName = document.getElementById('setup-ca-name')?.value?.trim() || '';\n      const dnsIP = document.getElementById('setup-dns-ip')?.value?.trim() || '';\n      const dnsPort = document.getElementById('setup-dns-port')?.value?.trim() || DC.DEFAULTS.DNS_PORT;\n\n      html += `\n        <div>\n          <h3 style=\"margin: 0 0 12px; color: var(--accent);\">Home Lab Configuration</h3>\n          <div style=\"display: grid; gap: 12px; font-size: 0.95rem;\">\n            <div><strong>TLD:</strong> ${tld}</div>\n            <div><strong>Certificate Authority:</strong> ${caName}</div>\n            <div><strong>DNS Server:</strong> ${dnsIP}:${dnsPort}</div>\n            <div><strong>Example URLs:</strong> https://uptime${tld}, https://nextcloud${tld}</div>\n          </div>\n        </div>\n      `;\n    } else if (currentConfigType === 'simple') {\n      const ip = document.getElementById('setup-simple-ip')?.value?.trim() || 'localhost';\n\n      html += `\n        <div>\n          <h3 style=\"margin: 0 0 12px; color: var(--accent);\">Simple Setup</h3>\n          <div style=\"display: grid; gap: 12px; font-size: 0.95rem;\">\n            <div><strong>Access Method:</strong> IP:Port only</div>\n            <div><strong>Default IP:</strong> ${ip}</div>\n            <div><strong>SSL:</strong> None (HTTP only)</div>\n            <div><strong>Example URLs:</strong> http://${ip}:8080, http://${ip}:3000</div>\n          </div>\n        </div>\n      `;\n    } else if (currentConfigType === 'public') {\n      const domain = document.getElementById('setup-public-domain')?.value?.trim() || '';\n      const email = document.getElementById('setup-public-email')?.value?.trim() || '';\n      const routingMode = document.querySelector('input[name=\"routing-mode\"]:checked')?.value || 'subdirectory';\n      const exampleUrls = routingMode === 'subdirectory'\n        ? `https://${domain}/sonarr, https://${domain}/grafana`\n        : `https://sonarr.${domain}, https://grafana.${domain}`;\n      const routingLabel = routingMode === 'subdirectory' ? 'Subdirectory (domain.com/app)' : 'Subdomain (app.domain.com)';\n\n      html += `\n        <div>\n          <h3 style=\"margin: 0 0 12px; color: var(--accent);\">Public Server</h3>\n          <div style=\"display: grid; gap: 12px; font-size: 0.95rem;\">\n            <div><strong>Domain:</strong> ${domain}</div>\n            <div><strong>SSL:</strong> Let's Encrypt</div>\n            <div><strong>Email:</strong> ${email}</div>\n            <div><strong>Routing:</strong> ${routingLabel}</div>\n            <div><strong>Example URLs:</strong> ${exampleUrls}</div>\n          </div>\n        </div>\n      `;\n    }\n\n    // Timezone (universal across all config types)\n    const tz = document.getElementById('setup-timezone')?.value || Intl.DateTimeFormat().resolvedOptions().timeZone || 'UTC';\n    html += `\n      <div style=\"margin-top: 8px; padding-top: 12px; border-top: 1px solid var(--border);\">\n        <div style=\"font-size: 0.95rem;\"><strong>Timezone:</strong> ${tz.replace(/_/g, ' ')}</div>\n      </div>\n    `;\n\n    html += '</div>';\n    summaryContent.innerHTML = html;\n    showStep('setup-step-summary');\n  }\n\n  // Save config to server\n  async function saveConfigToServer(config) {\n    try {\n      const response = await secureFetch('/api/v1/config', {\n        method: 'POST',\n        headers: { 'Content-Type': 'application/json' },\n        body: JSON.stringify(config)\n      });\n\n      if (response.ok) {\n        await response.json();\n        return true;\n      } else {\n        errorHandler.logError('[SetupWizard] Save Config', new Error(`Server returned ${response.status}`), { function: 'saveConfigToServer' });\n        return false;\n      }\n    } catch (error) {\n      errorHandler.logError('[SetupWizard] Save Config', error, { function: 'saveConfigToServer' });\n      return false;\n    }\n  }\n\n  // Finish setup handler\n  async function finishSetup() {\n    const config = {\n      setupComplete: true,\n      configurationType: currentConfigType,\n      timestamp: new Date().toISOString(),\n      timezone: document.getElementById('setup-timezone')?.value || Intl.DateTimeFormat().resolvedOptions().timeZone || 'UTC'\n    };\n\n    if (currentConfigType === 'homelab') {\n      config.tld = document.getElementById('setup-tld')?.value?.trim() || '.home';\n      config.caName = document.getElementById('setup-ca-name')?.value?.trim() || '';\n      const selectedProvider = document.getElementById('setup-dns-provider')?.value || 'technitium';\n      config.dns = {\n        provider: selectedProvider,\n        ip: document.getElementById('setup-dns-ip')?.value?.trim() || '',\n        port: document.getElementById('setup-dns-port')?.value?.trim() || DC.DEFAULTS.DNS_PORT,\n        token: document.getElementById('setup-dns-token')?.value?.trim() || ''\n      };\n      config.defaults = {\n        dnsType: 'private',\n        sslType: 'internal',\n        targetIP: 'localhost'\n      };\n    } else if (currentConfigType === 'simple') {\n      config.defaultIP = document.getElementById('setup-simple-ip')?.value?.trim() || 'localhost';\n      config.defaults = {\n        dnsType: 'none',\n        sslType: 'none',\n        targetIP: config.defaultIP\n      };\n    } else if (currentConfigType === 'public') {\n      config.domain = document.getElementById('setup-public-domain')?.value?.trim() || '';\n      config.email = document.getElementById('setup-public-email')?.value?.trim() || '';\n      config.routingMode = document.querySelector('input[name=\"routing-mode\"]:checked')?.value || 'subdirectory';\n      config.defaults = {\n        dnsType: config.routingMode === 'subdirectory' ? 'none' : 'public',\n        sslType: 'letsencrypt',\n        targetIP: 'localhost'\n      };\n    }\n\n    // Save to server (primary) and localStorage (fallback)\n    const savedToServer = await saveConfigToServer(config);\n    safeSet('dashcaddy-config', JSON.stringify(config));\n    safeSet('dashcaddy-setup', 'completed');\n\n    // Hide wizard\n    document.getElementById('setup-wizard').style.display = 'none';\n\n    // Show success notification\n    const configName = currentConfigType === 'homelab' ? 'Professional Home Lab' :\n                      currentConfigType === 'simple' ? 'Simple Setup' : 'Public Server';\n    const saveLocation = savedToServer ? 'server (shared across all devices)' : 'locally (this browser only)';\n\n    showNotification(`Setup Complete! Configured for: ${configName}. Settings saved to: ${saveLocation}`, 'success', 5000);\n\n    // Reload page to apply configuration\n    setTimeout(() => location.reload(), 500);\n  }\n\n  // ===== Event Handlers using direct onclick for reliability =====\n\n  // Step 1: Continue button\n  const step1Next = document.getElementById('setup-step-1-next');\n  if (step1Next) {\n    step1Next.onclick = function(e) {\n      e.preventDefault();\n      const selected = document.querySelector('input[name=\"config-type\"]:checked');\n      if (selected) {\n        currentConfigType = selected.value;\n      }\n      if (currentConfigType === 'homelab') {\n        showStep('setup-step-homelab');\n      } else if (currentConfigType === 'simple') {\n        showStep('setup-step-simple');\n      } else if (currentConfigType === 'public') {\n        showStep('setup-step-public');\n      } else {\n        showStep('setup-step-homelab');\n      }\n    };\n  }\n\n  // Skip setup button\n  const skipBtn = document.getElementById('setup-skip');\n  if (skipBtn) {\n    skipBtn.onclick = async function(e) {\n      e.preventDefault();\n      if (confirm('Skip setup? You can run it later from Settings.')) {\n        // Save skip status to server\n        await saveConfigToServer({ setupComplete: true, skipped: true, timestamp: new Date().toISOString() });\n        safeSet('dashcaddy-setup', 'skipped');\n        document.getElementById('setup-wizard').style.display = 'none';\n      }\n    };\n  }\n\n  // Home Lab: TLD Preview\n  const tldInput = document.getElementById('setup-tld');\n  if (tldInput) {\n    tldInput.oninput = function(e) {\n      const tld = e.target.value || '.home';\n      const preview1 = document.getElementById('tld-preview');\n      const preview2 = document.getElementById('tld-preview-2');\n      if (preview1) preview1.textContent = tld;\n      if (preview2) preview2.textContent = tld;\n    };\n  }\n\n  // Home Lab navigation\n  const homelabBack = document.getElementById('setup-homelab-back');\n  if (homelabBack) {\n    homelabBack.onclick = function(e) {\n      e.preventDefault();\n      showStep('setup-step-1');\n    };\n  }\n\n  const homelabNext = document.getElementById('setup-homelab-next');\n  if (homelabNext) {\n    homelabNext.onclick = function(e) {\n      e.preventDefault();\n      const tld = document.getElementById('setup-tld')?.value?.trim() || '';\n      const caName = document.getElementById('setup-ca-name')?.value?.trim() || '';\n      const dnsIP = document.getElementById('setup-dns-ip')?.value?.trim() || '';\n\n      if (!tld || !tld.startsWith('.')) {\n        showNotification('Please enter a valid TLD starting with a dot (e.g., .home)', 'warning');\n        return;\n      }\n      if (!caName) {\n        showNotification('Please enter a Certificate Authority name', 'warning');\n        return;\n      }\n      if (!dnsIP) {\n        showNotification('Please enter your DNS server IP address', 'warning');\n        return;\n      }\n      showSummary();\n    };\n  }\n\n  // Simple navigation\n  const simpleBack = document.getElementById('setup-simple-back');\n  if (simpleBack) {\n    simpleBack.onclick = function(e) {\n      e.preventDefault();\n      showStep('setup-step-1');\n    };\n  }\n\n  const simpleNext = document.getElementById('setup-simple-next');\n  if (simpleNext) {\n    simpleNext.onclick = function(e) {\n      e.preventDefault();\n      showSummary();\n    };\n  }\n\n  // Public routing mode toggle \u2014 update requirement text\n  document.querySelectorAll('input[name=\"routing-mode\"]').forEach(function(radio) {\n    radio.onchange = function() {\n      var note = document.getElementById('dns-requirement-note');\n      if (note) {\n        note.textContent = this.value === 'subdirectory'\n          ? 'Only one DNS record needed (for the main domain)'\n          : 'You\\'ll need to configure DNS manually for each subdomain';\n      }\n    };\n  });\n\n  // Public navigation\n  const publicBack = document.getElementById('setup-public-back');\n  if (publicBack) {\n    publicBack.onclick = function(e) {\n      e.preventDefault();\n      showStep('setup-step-1');\n    };\n  }\n\n  const publicNext = document.getElementById('setup-public-next');\n  if (publicNext) {\n    publicNext.onclick = function(e) {\n      e.preventDefault();\n      const domain = document.getElementById('setup-public-domain')?.value?.trim() || '';\n      const email = document.getElementById('setup-public-email')?.value?.trim() || '';\n\n      if (!domain) {\n        showNotification('Please enter your domain name', 'warning');\n        return;\n      }\n      if (!email || !email.includes('@')) {\n        showNotification('Please enter a valid email address', 'warning');\n        return;\n      }\n      showSummary();\n    };\n  }\n\n  // Summary navigation\n  const summaryBack = document.getElementById('setup-summary-back');\n  if (summaryBack) {\n    summaryBack.onclick = function(e) {\n      e.preventDefault();\n      if (currentConfigType === 'homelab') {\n        showStep('setup-step-homelab');\n      } else if (currentConfigType === 'simple') {\n        showStep('setup-step-simple');\n      } else if (currentConfigType === 'public') {\n        showStep('setup-step-public');\n      }\n    };\n  }\n\n  // Summary \"Continue \u2192\" \u2014 advance to the disk-safety warning step\n  const summaryNext = document.getElementById('setup-summary-next');\n  if (summaryNext) {\n    summaryNext.onclick = function(e) {\n      e.preventDefault();\n      showStep('setup-step-disk-safety');\n    };\n  }\n\n  // Disk-safety step navigation\n  const diskSafetyBack = document.getElementById('setup-disk-safety-back');\n  if (diskSafetyBack) {\n    diskSafetyBack.onclick = function(e) {\n      e.preventDefault();\n      showStep('setup-step-summary');\n    };\n  }\n\n  // Finish setup button (now on the disk-safety step)\n  const finishBtn = document.getElementById('setup-disk-safety-finish');\n  if (finishBtn) {\n    finishBtn.onclick = function(e) {\n      e.preventDefault();\n      finishSetup();\n    };\n  }\n\n  // Expose function to get global config (from server or localStorage)\n  window.getGlobalConfig = async function() {\n    // Try server first\n    try {\n      const response = await fetch('/api/v1/config');\n      if (response.ok) {\n        const config = await response.json();\n        if (config && config.setupComplete) {\n          return config;\n        }\n      }\n    } catch (e) {\n      console.warn('Could not fetch config from server');\n    }\n\n    // Fallback to localStorage\n    const configStr = safeGet('dashcaddy-config');\n    if (configStr) {\n      return JSON.parse(configStr);\n    }\n\n    // Return default config if not set\n    return {\n      setupComplete: false,\n      configurationType: 'homelab',\n      tld: '.home',\n      caName: '',\n      defaults: {\n        dnsType: 'private',\n        sslType: 'internal',\n        targetIP: 'localhost'\n      }\n    };\n  };\n\n  // Expose reset function for settings\n  window.resetSetupWizard = async function() {\n    if (confirm('Reset DashCaddy configuration? This will show the setup wizard again.')) {\n      try {\n        await secureFetch('/api/v1/config', { method: 'DELETE' });\n      } catch (e) {\n        console.warn('Could not delete server config');\n      }\n      safeRemove('dashcaddy-setup');\n      safeRemove('dashcaddy-config');\n      location.reload();\n    }\n  };\n})();\n;\n// App Selector System\n(function () {\n  const errorHandler = new ErrorHandler();\n  injectModal('app-selector-modal', `<div id=\"app-selector-modal\" class=\"weather-modal\">\n    <div class=\"app-selector-content\">\n      <h2 style=\"margin: 0 0 24px; color: var(--fg); text-align: center;\">Choose an App</h2>\n      <div id=\"app-selector-grid\" class=\"app-selector-grid\"></div>\n      <div style=\"text-align: center; margin-top: 24px;\">\n        <button id=\"app-selector-cancel\">Cancel</button>\n      </div>\n    </div>\n  </div>`);\n\n  injectModal('app-deploy-modal', `<div id=\"app-deploy-modal\" class=\"weather-modal\">\n    <div class=\"weather-modal-content\" style=\"min-width: 600px; max-width: 700px;\">\n      <h3 id=\"app-deploy-title\">Deploy Application</h3>\n\n      <div style=\"display: grid; grid-template-columns: 1fr; gap: 16px; margin-top: 16px;\">\n        <!-- Subdomain/Domain -->\n        <div>\n          <label for=\"deploy-subdomain\" class=\"form-label-accent-sm\">\n            \uD83C\uDF10 Subdomain or Domain\n          </label>\n          <input type=\"text\" id=\"deploy-subdomain\" placeholder=\"uptime\"\n                 style=\"width: 100%; padding: 10px; background: var(--card-bg); color: var(--fg); border: 1px solid var(--border); border-radius: 6px; font-size: 0.95rem;\" />\n          <div class=\"form-hint-sm\">\n            Your app will be available at: <span id=\"deploy-url-preview\" style=\"color: var(--accent); font-weight: 500;\">uptime.home</span>\n          </div>\n          <div id=\"subpath-compat-warning\" style=\"display: none; padding: 8px 12px; border-radius: 6px; background: color-mix(in srgb, #ff9800 10%, var(--card-bg)); border: 1px solid color-mix(in srgb, #ff9800 30%, transparent); margin-top: 8px; font-size: 0.85rem;\"></div>\n        </div>\n\n        <!-- DNS Configuration -->\n        <div>\n          <label class=\"form-label-accent\">\n            \uD83D\uDDC2\uFE0F DNS Configuration\n          </label>\n          <div class=\"flex-col-gap\">\n            <label class=\"radio-option\">\n              <input type=\"radio\" name=\"dns-type\" value=\"private\" checked style=\"margin-right: 10px;\" />\n              <div>\n                <div class=\"fw-500\">Private DNS (Technitium)</div>\n                <div class=\"text-hint\">Use your local DNS server with custom TLD (.sami, .home, etc.)</div>\n              </div>\n            </label>\n            <label class=\"radio-option\">\n              <input type=\"radio\" name=\"dns-type\" value=\"public\" style=\"margin-right: 10px;\" />\n              <div>\n                <div class=\"fw-500\">Public DNS</div>\n                <div class=\"text-hint\">Use a real domain (example.com) - requires DNS provider setup</div>\n              </div>\n            </label>\n            <label class=\"radio-option\">\n              <input type=\"radio\" name=\"dns-type\" value=\"none\" style=\"margin-right: 10px;\" />\n              <div>\n                <div class=\"fw-500\">No DNS (IP:Port only)</div>\n                <div class=\"text-hint\">Access via IP address and port - no domain setup</div>\n              </div>\n            </label>\n          </div>\n        </div>\n\n        <!-- SSL Configuration -->\n        <div>\n          <label class=\"form-label-accent\">\n            \uD83D\uDD12 SSL/TLS Certificate\n          </label>\n          <div class=\"flex-col-gap\">\n            <label class=\"radio-option\">\n              <input type=\"radio\" name=\"ssl-type\" value=\"internal\" checked style=\"margin-right: 10px;\" />\n              <div>\n                <div class=\"fw-500\">Internal CA</div>\n                <div class=\"text-hint\">Use Caddy's internal certificate authority (self-signed)</div>\n              </div>\n            </label>\n            <label class=\"radio-option\">\n              <input type=\"radio\" name=\"ssl-type\" value=\"letsencrypt\" style=\"margin-right: 10px;\" />\n              <div>\n                <div class=\"fw-500\">Let's Encrypt</div>\n                <div class=\"text-hint\">Free public SSL certificate (requires public domain)</div>\n              </div>\n            </label>\n            <label class=\"radio-option\">\n              <input type=\"radio\" name=\"ssl-type\" value=\"none\" style=\"margin-right: 10px;\" />\n              <div>\n                <div class=\"fw-500\">No SSL (HTTP only)</div>\n                <div class=\"text-hint\">\u26A0\uFE0F Not recommended - traffic will be unencrypted</div>\n              </div>\n            </label>\n          </div>\n        </div>\n\n        <!-- Media Library Path (shown for media apps) -->\n        <div id=\"media-path-section\" style=\"display: none;\">\n          <label class=\"form-label-accent\">\n            \uD83D\uDCC1 Media Library Location\n          </label>\n          <div style=\"display: flex; flex-direction: column; gap: 10px;\">\n            <!-- Detected mounts from existing media servers -->\n            <div id=\"detected-mounts-container\" style=\"display: none;\">\n              <div style=\"font-size: 0.85rem; color: var(--success); margin-bottom: 6px;\">\n                \u2713 Detected from existing media servers:\n              </div>\n              <div id=\"detected-mounts-list\" style=\"display: flex; gap: 8px; flex-wrap: wrap;\"></div>\n            </div>\n\n            <!-- Path input with browse button -->\n            <div class=\"flex-row-gap\">\n              <input type=\"text\" id=\"deploy-media-path\" placeholder=\"/media/Movies, /media/TVShows\"\n                     class=\"input-flex\" style=\"font-size: 0.95rem;\" />\n              <button type=\"button\" id=\"browse-media-btn\" style=\"padding: 10px 16px; background: var(--accent); color: white; border: none; border-radius: 6px; cursor: pointer; font-weight: 500; white-space: nowrap;\">\n                \uD83D\uDCC2 Browse\n              </button>\n            </div>\n\n            <div id=\"media-path-description\" class=\"text-hint\">\n              Select folders from existing servers, browse, or type paths manually. Separate multiple with commas.\n            </div>\n\n            <!-- Selected paths display -->\n            <div id=\"selected-media-paths\" style=\"display: none; flex-wrap: wrap; gap: 6px;\"></div>\n          </div>\n        </div>\n\n        <!-- Plex Claim Token (shown only for Plex deployments) -->\n        <div id=\"plex-claim-section\" style=\"display: none;\">\n          <label class=\"form-label-accent\">\n            \uD83D\uDD11 Plex Claim Token\n          </label>\n          <div class=\"flex-row-gap\">\n            <input type=\"text\" id=\"deploy-plex-claim\" placeholder=\"claim-xxxxxxxxxxxxxxxxxxxx\"\n                   class=\"input-flex\" style=\"font-size: 0.95rem;\" />\n            <a href=\"https://plex.tv/claim\" target=\"_blank\" rel=\"noopener noreferrer\"\n               style=\"padding: 10px 16px; background: #e5a00d; color: #000; border: none; border-radius: 6px; cursor: pointer; font-weight: 500; white-space: nowrap; text-decoration: none; display: flex; align-items: center;\">\n              Get Token\n            </a>\n          </div>\n          <div style=\"font-size: 0.8rem; color: #e5a00d; margin-top: 4px;\">\n            Token expires in 4 minutes! Get it right before clicking Deploy. Leave empty to configure Plex manually later.\n          </div>\n        </div>\n\n        <!-- Tailscale Security -->\n        <div id=\"tailscale-section\">\n          <label class=\"form-label-accent\">\n            \uD83D\uDD10 Tailscale Security\n          </label>\n          <div class=\"flex-col-gap\">\n            <label class=\"radio-option\">\n              <input type=\"checkbox\" id=\"deploy-tailscale-only\" style=\"margin-right: 10px; width: 18px; height: 18px;\" />\n              <div>\n                <div class=\"fw-500\">Tailscale-Only Access</div>\n                <div class=\"text-hint\">Restrict this service to Tailscale users only (100.x.x.x IPs)</div>\n              </div>\n            </label>\n            <div id=\"tailscale-status\" style=\"padding: 8px 12px; background: var(--card-bg); border-radius: 6px; font-size: 0.85rem;\">\n              <span style=\"color: var(--muted);\">Checking Tailscale status...</span>\n            </div>\n          </div>\n        </div>\n\n        <!-- Advanced Options (Collapsible) -->\n        <details>\n          <summary style=\"cursor: pointer; color: var(--accent); font-weight: 500; margin-bottom: 8px;\">\u2699\uFE0F Advanced Options</summary>\n          <div style=\"margin-top: 12px; display: grid; gap: 12px;\">\n            <div>\n              <label for=\"deploy-port\" style=\"display: block; margin-bottom: 6px;\">Custom Port (optional)</label>\n              <input type=\"number\" id=\"deploy-port\" placeholder=\"Leave empty for default\"\n                     class=\"form-input-card\" />\n            </div>\n            <div>\n              <label for=\"deploy-ip\" style=\"display: block; margin-bottom: 6px;\">Target IP Address</label>\n              <input type=\"text\" id=\"deploy-ip\" value=\"localhost\"\n                     class=\"form-input-card\" />\n              <div class=\"form-hint-sm\">\n                Use 'localhost' for same-host containers, or specific IP for remote services\n              </div>\n            </div>\n            <div id=\"volume-mounts-section\" style=\"display: none;\">\n              <label class=\"form-label-accent-sm\">\uD83D\uDCC2 Volume Mounts</label>\n              <div style=\"font-size: 0.8rem; color: var(--muted); margin-bottom: 8px;\">\n                Customize where container data is stored on the host. Media volumes are configured above.\n              </div>\n              <div id=\"volume-mounts-list\" style=\"display: grid; gap: 8px;\"></div>\n            </div>\n            <div style=\"margin-top: 12px;\">\n              <label class=\"form-label-accent-sm\">\u2699\uFE0F Resource Limits</label>\n              <div style=\"font-size: 0.8rem; color: var(--muted); margin-bottom: 8px;\">\n                Optional CPU and memory constraints. Leave at 0 for unlimited.\n              </div>\n              <div style=\"display: grid; grid-template-columns: 1fr 1fr; gap: 10px;\">\n                <div>\n                  <label for=\"deploy-cpu-limit\" style=\"display: block; font-size: 0.78rem; color: var(--muted); margin-bottom: 4px;\">CPU Cores</label>\n                  <input type=\"number\" id=\"deploy-cpu-limit\" value=\"0\" min=\"0\" max=\"64\" step=\"0.25\" class=\"form-input-card\" style=\"width: 100%;\" placeholder=\"0 = unlimited\" />\n                </div>\n                <div>\n                  <label for=\"deploy-memory-limit\" style=\"display: block; font-size: 0.78rem; color: var(--muted); margin-bottom: 4px;\">Memory (MB)</label>\n                  <input type=\"number\" id=\"deploy-memory-limit\" value=\"0\" min=\"0\" max=\"131072\" step=\"64\" class=\"form-input-card\" style=\"width: 100%;\" placeholder=\"0 = unlimited\" />\n                </div>\n              </div>\n            </div>\n          </div>\n        </details>\n      </div>\n\n      <div class=\"weather-modal-buttons\" style=\"margin-top: 24px;\">\n        <button id=\"app-deploy-cancel\">Cancel</button>\n        <button id=\"app-deploy-confirm\" class=\"btn-accent\">\n          \uD83D\uDE80 Deploy\n        </button>\n      </div>\n    </div>\n  </div>`);\n\n  const APPS_KEY = 'custom-apps';\n\n  // Cache for API templates\n  let apiTemplates = null;\n  let apiCategories = null;\n\n  const modal = document.getElementById('app-selector-modal');\n  const grid = document.getElementById('app-selector-grid');\n\n  // Fetch app templates from API\n  async function fetchAppTemplates() {\n    try {\n      const response = await fetch('/api/v1/apps/templates');\n      const data = await response.json();\n      if (data.success) {\n        apiTemplates = data.templates;\n        apiCategories = data.categories;\n        return true;\n      }\n    } catch (e) {\n      errorHandler.logError('[AppSelector] Fetch Templates', e, { function: 'fetchApiTemplates' });\n    }\n    return false;\n  }\n\n  // Check port availability\n  async function checkPortAvailability(port) {\n    try {\n      const response = await fetch(`/api/v1/apps/ports/${port}/check`);\n      const data = await response.json();\n      return data;\n    } catch (e) {\n      errorHandler.logError('[AppSelector] Check Port', e, { function: 'checkPortAvailability' });\n      return { available: true }; // Assume available on error\n    }\n  }\n\n  // Get suggested available port\n  async function getSuggestedPort(basePort) {\n    try {\n      const response = await fetch(`/api/v1/apps/ports/${basePort}/suggest`);\n      const data = await response.json();\n      if (data.success) {\n        return data.suggestedPort;\n      }\n    } catch (e) {\n      errorHandler.logError('[AppSelector] Get Suggested Port', e, { function: 'getSuggestedPort' });\n    }\n    return basePort;\n  }\n\n  // Build app selector grid from API templates\n  async function buildAppSelector() {\n    grid.innerHTML = '<div style=\"text-align: center; padding: 40px; color: var(--muted);\">Loading app templates...</div>';\n\n    // Fetch templates if not cached\n    if (!apiTemplates) {\n      const success = await fetchAppTemplates();\n      if (!success) {\n        grid.innerHTML = '<div style=\"text-align: center; padding: 40px; color: var(--error);\">Failed to load app templates. Please try again.</div>';\n        return;\n      }\n    }\n\n    grid.innerHTML = '';\n\n    // Group templates by category\n    const byCategory = {};\n    for (const [appId, template] of Object.entries(apiTemplates)) {\n      const category = template.category || 'Other';\n      if (!byCategory[category]) {\n        byCategory[category] = [];\n      }\n      byCategory[category].push({ id: appId, ...template });\n    }\n\n    // Sort categories by the order in apiCategories if available\n    const categoryOrder = apiCategories ? Object.keys(apiCategories) : Object.keys(byCategory).sort();\n\n    for (const category of categoryOrder) {\n      const apps = byCategory[category];\n      if (!apps || apps.length === 0) continue;\n\n      // Sort apps by popularity (descending)\n      apps.sort((a, b) => (b.popularity || 0) - (a.popularity || 0));\n\n      // Category header with icon and color from API\n      const header = document.createElement('div');\n      header.className = 'app-category-header';\n      const categoryInfo = apiCategories?.[category] || {};\n      header.innerHTML = `${escapeHtml(categoryInfo.icon || '')} ${escapeHtml(category)}`;\n      if (categoryInfo.color) {\n        header.style.borderBottomColor = categoryInfo.color;\n      }\n      grid.appendChild(header);\n\n      // App options\n      apps.forEach(app => {\n        const option = document.createElement('div');\n        option.className = 'app-option';\n\n        // Widget enabled badge\n        const isWidget = app.isDashboardWidget;\n        const widgetEnabled = isWidget && safeGet('widget-' + app.id + '-enabled') !== 'false';\n        const widgetBadge = isWidget\n          ? `<div style=\"font-size: 0.65rem; padding: 2px 6px; border-radius: 4px; margin-top: 4px; background: ${widgetEnabled ? '#2ecc7130' : '#e74c3c30'}; color: ${widgetEnabled ? '#2ecc71' : '#e74c3c'}; font-weight: 600;\">${widgetEnabled ? 'ON' : 'OFF'}</div>`\n          : '';\n\n        // Show difficulty badge (non-widgets only)\n        const difficultyBadge = !isWidget && app.difficulty ?\n          `<div style=\"font-size: 0.65rem; padding: 2px 6px; border-radius: 4px; margin-top: 4px; background: ${\n            app.difficulty === 'Easy' ? '#2ecc71' :\n            app.difficulty === 'Intermediate' ? '#f39c12' : '#e74c3c'\n          }20; color: ${\n            app.difficulty === 'Easy' ? '#2ecc71' :\n            app.difficulty === 'Intermediate' ? '#f39c12' : '#e74c3c'\n          };\">${escapeHtml(app.difficulty)}</div>` : '';\n\n        option.innerHTML = `\n          <div class=\"app-option-icon\">${escapeHtml(app.icon || '\uD83D\uDCE6')}</div>\n          <div class=\"app-option-name\">${escapeHtml(app.name)}</div>\n          <div class=\"app-option-desc\">${escapeHtml(app.description || '')}</div>\n          ${widgetBadge}${difficultyBadge}\n        `;\n\n        if (isWidget) {\n          option.onclick = () => toggleDashboardWidget(app, option);\n        } else {\n          option.onclick = () => showDeployConfig(app);\n        }\n        grid.appendChild(option);\n      });\n    }\n\n    // Render recipe cards at the end of the grid\n    if (window.renderRecipeCards) {\n      await window.renderRecipeCards(grid);\n    }\n  }\n\n  // Toggle a dashboard widget on/off\n  function toggleDashboardWidget(app, optionEl) {\n    const key = 'widget-' + app.id + '-enabled';\n    const currentlyEnabled = safeGet(key) !== 'false';\n    const newState = !currentlyEnabled;\n    safeSet(key, String(newState));\n\n    // Update visibility immediately\n    const selector = app.widgetSelector;\n    if (selector) {\n      const el = document.querySelector(selector);\n      if (el) el.style.display = newState ? '' : 'none';\n    }\n\n    // Update the badge in the app selector card\n    const badge = optionEl.querySelector('div[style*=\"border-radius: 4px\"]');\n    if (badge) {\n      badge.textContent = newState ? 'ON' : 'OFF';\n      badge.style.background = newState ? '#2ecc7130' : '#e74c3c30';\n      badge.style.color = newState ? '#2ecc71' : '#e74c3c';\n    }\n\n    showNotification(`${app.name} widget ${newState ? 'enabled' : 'disabled'}`, 'success', 2000);\n  }\n\n  // Show deployment configuration modal\n  async function showDeployConfig(appTemplate) {\n    const deployModal = document.getElementById('app-deploy-modal');\n    const title = document.getElementById('app-deploy-title');\n    const subdomainInput = document.getElementById('deploy-subdomain');\n    const urlPreview = document.getElementById('deploy-url-preview');\n    const ipInput = document.getElementById('deploy-ip');\n    const portInput = document.getElementById('deploy-port');\n    const tailscaleCheckbox = document.getElementById('deploy-tailscale-only');\n    const tailscaleStatus = document.getElementById('tailscale-status');\n\n    // Check for existing container with same image\n    try {\n      const checkResponse = await secureFetch('/api/v1/apps/check-existing', {\n        method: 'POST',\n        headers: { 'Content-Type': 'application/json' },\n        body: JSON.stringify({ appId: appTemplate.id })\n      });\n      const checkResult = await checkResponse.json();\n\n      if (checkResult.success && checkResult.exists) {\n        const container = checkResult.container;\n        const useExisting = confirm(\n          `Found existing ${appTemplate.name} container:\\n\\n` +\n          `Container: ${container.name}\\n` +\n          `Status: ${container.status}\\n` +\n          `Port: ${container.primaryPort || 'N/A'}\\n\\n` +\n          `Would you like to use this existing container?\\n\\n` +\n          `Click OK to configure DNS/Caddy for the existing container.\\n` +\n          `Click Cancel to deploy a new container.`\n        );\n\n        if (useExisting) {\n          // Store existing container info for deployment\n          appTemplate._useExisting = true;\n          appTemplate._existingContainer = container;\n        }\n      }\n    } catch (e) {\n      // Ignore container check errors\n    }\n\n    // Set title with app info\n    title.textContent = `Deploy ${appTemplate.name}`;\n\n    // Pre-fill subdomain from template or app ID\n    const defaultSubdomain = appTemplate.subdomain || appTemplate.id.replace(/-/g, '');\n    subdomainInput.value = defaultSubdomain;\n\n    // Show subpath compatibility warning in subdirectory mode\n    const subpathWarning = document.getElementById('subpath-compat-warning');\n    if (subpathWarning) {\n      if (SITE.routingMode === 'subdirectory') {\n        const support = appTemplate.subpathSupport || 'strip';\n        if (support === 'none') {\n          subpathWarning.style.display = 'block';\n          subpathWarning.innerHTML = '<span style=\"color: #ff9800;\">&#9888; <strong>' + appTemplate.name + '</strong> does not support subdirectory mode. It may not work correctly at a subpath.</span>';\n        } else if (support === 'strip') {\n          subpathWarning.style.display = 'block';\n          subpathWarning.innerHTML = '<span style=\"color: var(--muted);\">&#9432; ' + appTemplate.name + ' has unverified subdirectory support. It may require additional configuration.</span>';\n        } else {\n          subpathWarning.style.display = 'none';\n        }\n      } else {\n        subpathWarning.style.display = 'none';\n      }\n    }\n\n    // Pre-select DNS/SSL from site config (set during setup wizard)\n    const cfgDnsType = SITE.defaults.dnsType || (SITE.configurationType === 'public' ? 'public' : 'private');\n    const cfgSslType = SITE.defaults.sslType || (SITE.configurationType === 'public' ? 'letsencrypt' : 'internal');\n    const dnsRadio = document.querySelector(`input[name=\"dns-type\"][value=\"${cfgDnsType}\"]`);\n    const sslRadio = document.querySelector(`input[name=\"ssl-type\"][value=\"${cfgSslType}\"]`);\n    if (dnsRadio) dnsRadio.checked = true;\n    else document.querySelector('input[name=\"dns-type\"][value=\"private\"]').checked = true;\n    if (sslRadio) sslRadio.checked = true;\n    else document.querySelector('input[name=\"ssl-type\"][value=\"internal\"]').checked = true;\n    ipInput.value = SITE.defaults.targetIP || 'localhost';\n    tailscaleCheckbox.checked = false;\n\n    // Move DNS/SSL into Advanced section when already configured\n    const dnsSection = document.querySelector('#app-deploy-modal .flex-col-gap')?.closest('div');\n    const advancedDetails = document.querySelector('#app-deploy-modal details');\n    const advancedContent = advancedDetails?.querySelector('div');\n    if (advancedDetails && advancedContent && (SITE.configurationType === 'public' || SITE.configurationType === 'homelab')) {\n      // Move DNS and SSL sections inside Advanced\n      const dnsSectionEl = document.querySelectorAll('#app-deploy-modal input[name=\"dns-type\"]')[0]?.closest('div.flex-col-gap')?.parentElement;\n      const sslSectionEl = document.querySelectorAll('#app-deploy-modal input[name=\"ssl-type\"]')[0]?.closest('div.flex-col-gap')?.parentElement;\n      if (dnsSectionEl && !dnsSectionEl.dataset.moved) {\n        advancedContent.appendChild(dnsSectionEl);\n        dnsSectionEl.dataset.moved = '1';\n      }\n      if (sslSectionEl && !sslSectionEl.dataset.moved) {\n        advancedContent.appendChild(sslSectionEl);\n        sslSectionEl.dataset.moved = '1';\n      }\n    }\n\n    // Handle media path section for media apps\n    const mediaPathSection = document.getElementById('media-path-section');\n    const mediaPathInput = document.getElementById('deploy-media-path');\n    const mediaPathDescription = document.getElementById('media-path-description');\n\n    if (appTemplate.mediaMount) {\n      mediaPathSection.style.display = 'block';\n      mediaPathInput.value = '';\n      mediaPathInput.placeholder = '/media/Movies, /media/TVShows or click Browse';\n\n      // Fetch detected mounts from existing media servers\n      const detectedMountsContainer = document.getElementById('detected-mounts-container');\n      const detectedMountsList = document.getElementById('detected-mounts-list');\n\n      try {\n        const mountsResponse = await fetch('/api/v1/media/detected-mounts');\n        const mountsResult = await mountsResponse.json();\n\n        if (mountsResult.success && mountsResult.mounts.length > 0) {\n          detectedMountsContainer.style.display = 'block';\n          detectedMountsList.innerHTML = '';\n\n          // Auto-fill media path with all detected mounts\n          const autoPaths = [...new Set(mountsResult.mounts.map(m => m.hostPath))];\n          mediaPathInput.value = autoPaths.join(', ');\n\n          mountsResult.mounts.forEach(mount => {\n            const btn = document.createElement('button');\n            btn.type = 'button';\n            const isSelected = autoPaths.includes(mount.hostPath);\n            btn.style.cssText = `padding: 8px 14px; font-size: 0.85rem; background: color-mix(in srgb, var(--success) ${isSelected ? '40%' : '15%'}, var(--card-bg)); border: 1px solid var(--success); border-radius: 6px; cursor: pointer; color: var(--fg);`;\n            btn.innerHTML = `<span style=\"font-weight: 500;\">${escapeHtml(mount.folderName)}</span><br><span style=\"font-size: 0.7rem; color: var(--muted);\">from ${escapeHtml(mount.sourceImage)}</span>`;\n            btn.title = `${mount.hostPath} (from ${mount.sourceContainer})`;\n            btn.onclick = () => {\n              const currentPaths = mediaPathInput.value.split(',').map(p => p.trim()).filter(p => p);\n              const idx = currentPaths.indexOf(mount.hostPath);\n              if (idx >= 0) {\n                currentPaths.splice(idx, 1);\n                btn.style.background = 'color-mix(in srgb, var(--success) 15%, var(--card-bg))';\n              } else {\n                currentPaths.push(mount.hostPath);\n                btn.style.background = 'color-mix(in srgb, var(--success) 40%, var(--card-bg))';\n              }\n              mediaPathInput.value = currentPaths.join(', ');\n            };\n            detectedMountsList.appendChild(btn);\n          });\n        } else {\n          detectedMountsContainer.style.display = 'none';\n        }\n      } catch (e) {\n        detectedMountsContainer.style.display = 'none';\n      }\n\n      // Set up browse button\n      document.getElementById('browse-media-btn').onclick = () => {\n        openFolderBrowser(mediaPathInput);\n      };\n    } else {\n      mediaPathSection.style.display = 'none';\n      mediaPathInput.value = '';\n      document.getElementById('detected-mounts-container').style.display = 'none';\n    }\n\n    // Show Plex claim token section for Plex deployments\n    const plexClaimSection = document.getElementById('plex-claim-section');\n    if (plexClaimSection) {\n      if (appTemplate.id === 'plex' || appTemplate.claimToken) {\n        plexClaimSection.style.display = 'block';\n        document.getElementById('deploy-plex-claim').value = '';\n      } else {\n        plexClaimSection.style.display = 'none';\n      }\n    }\n\n    // Populate volume mounts in Advanced Options\n    const volumeSection = document.getElementById('volume-mounts-section');\n    const volumeList = document.getElementById('volume-mounts-list');\n    volumeList.innerHTML = '';\n\n    if (appTemplate.docker?.volumes?.length) {\n      const mediaContainerPath = appTemplate.mediaMount?.containerPath;\n      const nonMediaVolumes = appTemplate.docker.volumes.filter(v => !v.includes('{{MEDIA_PATH}}') && !(mediaContainerPath && v.endsWith(':' + mediaContainerPath)));\n\n      if (nonMediaVolumes.length > 0) {\n        volumeSection.style.display = 'block';\n        nonMediaVolumes.forEach((vol, i) => {\n          const [hostDefault, containerPath] = vol.split(':');\n          const row = document.createElement('div');\n          row.style.cssText = 'display: flex; gap: 6px; align-items: center;';\n          row.innerHTML = `\n            <input type=\"text\" class=\"vol-host-path\" data-container-path=\"${containerPath}\" value=\"${hostDefault}\"\n                   style=\"flex: 1; padding: 8px; background: var(--card-bg); color: var(--fg); border: 1px solid var(--border); border-radius: 6px; font-size: 0.85rem;\" />\n            <span style=\"color: var(--muted); font-size: 0.85rem; white-space: nowrap;\">\u2192 ${containerPath}</span>\n            <button type=\"button\" class=\"vol-browse-btn\" style=\"padding: 8px 10px; background: var(--accent); color: white; border: none; border-radius: 6px; cursor: pointer; font-size: 0.8rem;\">\uD83D\uDCC2</button>\n          `;\n          volumeList.appendChild(row);\n          row.querySelector('.vol-browse-btn').onclick = () => {\n            const input = row.querySelector('.vol-host-path');\n            openFolderBrowser(input);\n          };\n        });\n      } else {\n        volumeSection.style.display = 'none';\n      }\n    } else {\n      volumeSection.style.display = 'none';\n    }\n\n    // Set default port from template and check availability\n    const defaultPort = appTemplate.defaultPort || 8080;\n    portInput.value = '';\n    portInput.placeholder = `Default: ${defaultPort}`;\n\n    // Add port status element if not exists\n    let portStatus = document.getElementById('deploy-port-status');\n    if (!portStatus) {\n      portStatus = document.createElement('div');\n      portStatus.id = 'deploy-port-status';\n      portStatus.style.cssText = 'font-size: 0.8rem; margin-top: 4px;';\n      portInput.parentNode.appendChild(portStatus);\n    }\n\n    // Check default port availability\n    async function checkAndUpdatePortStatus() {\n      const portToCheck = portInput.value || defaultPort;\n      portStatus.innerHTML = '<span style=\"color: var(--muted);\">Checking port...</span>';\n\n      const result = await checkPortAvailability(portToCheck);\n      if (result.available) {\n        portStatus.innerHTML = `<span style=\"color: #4caf50;\">Port ${escapeHtml(String(portToCheck))} is available</span>`;\n      } else {\n        const suggestedPort = await getSuggestedPort(defaultPort);\n        portStatus.innerHTML = `\n          <span style=\"color: #e74c3c;\">Port ${escapeHtml(portToCheck)} in use by ${escapeHtml(result.conflict?.usedBy || 'unknown')}</span>\n        `;\n        const useBtn = document.createElement('button');\n        useBtn.type = 'button';\n        useBtn.textContent = `Use ${suggestedPort}`;\n        useBtn.style.cssText = 'margin-left: 8px; padding: 2px 8px; font-size: 0.75rem; cursor: pointer;';\n        useBtn.onclick = () => {\n          document.getElementById('deploy-port').value = suggestedPort;\n          portStatus.innerHTML = `<span style=\"color: #4caf50;\">Using suggested port ${escapeHtml(String(suggestedPort))}</span>`;\n        };\n        portStatus.appendChild(useBtn);\n      }\n    }\n\n    // Check port on input change (debounced)\n    let portCheckTimeout;\n    portInput.oninput = function() {\n      clearTimeout(portCheckTimeout);\n      portCheckTimeout = setTimeout(checkAndUpdatePortStatus, 500);\n    };\n\n    // Initial port check\n    checkAndUpdatePortStatus();\n\n    // Fetch Tailscale status\n    try {\n      const response = await fetch('/api/v1/tailscale/status');\n      const data = await response.json();\n      if (data.success && data.installed && data.connected) {\n        tailscaleStatus.innerHTML = `\n          <span style=\"color: #4caf50;\">Connected</span>\n          <span style=\"color: var(--muted); margin-left: 8px;\">${data.self?.hostname} (${data.self?.ip})</span>\n          <span style=\"color: var(--muted); margin-left: 8px;\">| ${data.deviceCount} devices</span>\n        `;\n      } else if (data.installed) {\n        tailscaleStatus.innerHTML = `<span style=\"color: #ff9800;\">Not connected</span>`;\n      } else {\n        tailscaleStatus.innerHTML = `<span style=\"color: var(--muted);\">Not available</span>`;\n        tailscaleCheckbox.disabled = true;\n      }\n    } catch (e) {\n      tailscaleStatus.innerHTML = `<span style=\"color: var(--muted);\">Could not check status</span>`;\n    }\n\n    // Update URL preview in real-time\n    function updateUrlPreview() {\n      const subdomain = subdomainInput.value || 'subdomain';\n      const dnsType = document.querySelector('input[name=\"dns-type\"]:checked').value;\n      const sslType = document.querySelector('input[name=\"ssl-type\"]:checked').value;\n\n      let url = '';\n      if (SITE.routingMode === 'subdirectory' && SITE.domain) {\n        // Subdirectory mode: domain.com/app\n        url = `https://${SITE.domain}/${subdomain}`;\n      } else if (dnsType === 'private') {\n        const protocol = sslType === 'none' ? 'http' : 'https';\n        url = `${protocol}://${buildDomain(subdomain)}`;\n      } else if (dnsType === 'public') {\n        const protocol = sslType === 'none' ? 'http' : 'https';\n        const domain = SITE.domain || subdomain;\n        url = SITE.domain ? `${protocol}://${subdomain}.${SITE.domain}` : `${protocol}://${subdomain}`;\n      } else {\n        const port = portInput.value || appTemplate.defaultPort || DC.DEFAULTS.SERVICE_PORT;\n        url = `http://${ipInput.value}:${port}`;\n      }\n      urlPreview.textContent = url;\n    }\n\n    // Attach listeners\n    subdomainInput.oninput = updateUrlPreview;\n    ipInput.oninput = updateUrlPreview;\n    portInput.oninput = updateUrlPreview;\n    document.querySelectorAll('input[name=\"dns-type\"]').forEach(radio => {\n      radio.onchange = updateUrlPreview;\n    });\n    document.querySelectorAll('input[name=\"ssl-type\"]').forEach(radio => {\n      radio.onchange = updateUrlPreview;\n    });\n\n    updateUrlPreview();\n\n    // Close app selector, open deploy config\n    modal.classList.remove('show');\n    deployModal.classList.add('show');\n\n    // Store app template for deployment\n    deployModal.dataset.appTemplate = JSON.stringify(appTemplate);\n  }\n\n  // Add app to grid with full Docker deployment\n  async function addAppToGrid(deployConfig) {\n    const appTemplate = deployConfig.appTemplate;\n    const customApps = safeGetJSON(APPS_KEY, []);\n\n    // Check if using existing container\n    const usingExisting = appTemplate._useExisting && appTemplate._existingContainer;\n\n    // Check if app already exists - skip if using existing container (user already confirmed)\n    const existingApp = customApps.find(a => a.id === deployConfig.subdomain);\n    if (existingApp && !usingExisting) {\n      const confirmed = confirm(`An app with subdomain \"${deployConfig.subdomain}\" already exists. Redeploy?`);\n      if (!confirmed) return;\n    }\n    // Remove from localStorage to allow redeployment/update\n    if (existingApp) {\n      const index = customApps.indexOf(existingApp);\n      customApps.splice(index, 1);\n      safeSet(APPS_KEY, JSON.stringify(customApps));\n    }\n\n    // Check port availability before deployment (skip if using existing container)\n    if (!usingExisting) {\n      const portToUse = deployConfig.port || appTemplate.defaultPort || 8080;\n      showNotification(`Checking port ${portToUse} availability...`, 'info', 0);\n\n      const portCheck = await checkPortAvailability(portToUse);\n      if (!portCheck.available) {\n        const suggestedPort = await getSuggestedPort(appTemplate.defaultPort || 8080);\n        const useAlternate = confirm(\n          `Port ${portToUse} is already in use by ${portCheck.conflict?.usedBy || 'another container'}.\\n\\n` +\n          `Would you like to use port ${suggestedPort} instead?`\n        );\n        if (useAlternate) {\n          deployConfig.port = suggestedPort;\n        } else {\n          showNotification('Deployment cancelled - port conflict', 'error', 5000);\n          return;\n        }\n      }\n    } else {\n      // Use existing container's port\n      deployConfig.port = appTemplate._existingContainer.primaryPort;\n    }\n    showNotification(\n      usingExisting\n        ? `Configuring ${appTemplate.name} with existing container...`\n        : `Deploying ${appTemplate.name}...`,\n      'info', 0\n    );\n\n    try {\n      // Prepare deployment config from user's choices\n      const apiDeployConfig = {\n        appId: appTemplate.id,\n        config: {\n          subdomain: deployConfig.subdomain,\n          ip: deployConfig.ip,\n          createDns: deployConfig.dnsType === 'private',  // Only create DNS for private\n          port: deployConfig.port || appTemplate.defaultPort || null,  // Use custom, template default, or null\n          sslType: deployConfig.sslType,\n          dnsType: deployConfig.dnsType,\n          tailscaleOnly: deployConfig.tailscaleOnly || false,  // Tailscale-only access restriction\n          mediaPath: deployConfig.mediaPath || null,  // Media folder path for media apps\n          plexClaimToken: deployConfig.plexClaimToken || null,  // Plex claim token for auto-claim\n          customVolumes: deployConfig.customVolumes || null  // Custom volume mount overrides\n        }\n      };\n\n      // Add existing container info if using existing\n      if (usingExisting) {\n        apiDeployConfig.config.useExisting = true;\n        apiDeployConfig.config.existingContainerId = appTemplate._existingContainer.id;\n        apiDeployConfig.config.existingPort = appTemplate._existingContainer.primaryPort;\n        // Use existing container's port if no custom port specified\n        if (!deployConfig.port && appTemplate._existingContainer.primaryPort) {\n          apiDeployConfig.config.port = appTemplate._existingContainer.primaryPort;\n        }\n      }\n\n      // DC-CATALOG-3: deploy through shipdeck (no Docker daemon). The\n      // bridge renders the catalog entry server-side and runs the OCI\n      // image as a hardened systemd service. Same modal, same fields.\n      const catalogPayload = {\n        app: appTemplate.id,\n        port: deployConfig.port || appTemplate.defaultPort || null,\n        subdomain: deployConfig.subdomain || '',\n        media_path: deployConfig.mediaPath || '',\n        env: deployConfig.plexClaimToken ? { PLEX_CLAIM: deployConfig.plexClaimToken } : {}\n      };\n\n      const response = await secureFetch('/api/v1/deploys/catalog/deploy', {\n        method: 'POST',\n        headers: { 'Content-Type': 'application/json' },\n        body: JSON.stringify(catalogPayload)\n      });\n\n      const result = await response.json();\n\n      if (result.success) {\n        // Add to saved apps (store IP for later deletion)\n        const newApp = {\n          id: deployConfig.subdomain,  // Use subdomain as ID\n          name: appTemplate.name,\n          logo: `/assets/${appTemplate.id}.png`,\n          containerId: null,  // shipdeck deploys have no docker container id\n          url: result.url || `http://127.0.0.1:${catalogPayload.port}`,\n          ip: deployConfig.ip,  // Store IP for DNS record deletion\n          appTemplate: appTemplate.id,  // Store original template ID\n          tailscaleOnly: deployConfig.tailscaleOnly || false  // Tailscale protection status\n        };\n        customApps.push(newApp);\n        safeSet(APPS_KEY, JSON.stringify(customApps));\n\n        // Add to APPS array and rebuild grid\n        // Access APPS from parent scope via window\n        if (window.APPS && !window.APPS.some(a => a.id === appTemplate.id)) {\n          window.APPS.push(newApp);\n          if (typeof window.buildGrid === 'function') {\n            window.buildGrid();\n          }\n          if (typeof window.refreshAll === 'function') {\n            setTimeout(() => window.refreshAll(), 500);\n          }\n        }\n\n        // Show success with URL (and warning if DNS failed)\n        let message = result.usedExisting\n          ? `${appTemplate.name} configured with existing container!\\nURL: ${result.url}`\n          : `${appTemplate.name} deployed successfully!\\nURL: ${result.url}`;\n        if (result.warning) {\n          message += `\\n\\n\u26A0 Warning: ${result.warning}`;\n        }\n\n        showNotification(message, 'success', 8000);\n\n        // Clean up temporary properties\n        delete appTemplate._useExisting;\n        delete appTemplate._existingContainer;\n        \n        // For HTTPS URLs, check SSL certificate status\n        if (result.url && result.url.startsWith('https://')) {\n          checkSSLCertificate(result.url, appTemplate.name);\n        }\n\n        // Show setup instructions if available\n        if (result.setupInstructions && result.setupInstructions.length > 0) {\n          setTimeout(() => {\n            const instructions = result.setupInstructions.join('\\n');\n            showNotification(`Setup Instructions for ${appTemplate.name}: ${instructions}`, 'info', 10000);\n          }, 1000);\n        }\n      } else {\n        throw new Error(result.error || 'Deployment failed');\n      }\n    } catch (error) {\n      errorHandler.logError('[AppSelector] Deployment', error, { function: 'deploy' });\n      showNotification(\n        `Failed to deploy ${appTemplate.name}: ${error.message}`,\n        'error',\n        8000\n      );\n    }\n  }\n\n  // Check SSL certificate status and notify when ready\n  async function checkSSLCertificate(url, appName) {\n    showNotification(`\u23F3 Generating SSL certificate for ${appName}...`, 'warning', 60000);\n    \n    let attempts = 0;\n    const maxAttempts = 12; // 60 seconds total (5 second intervals)\n    \n    const checkCert = async () => {\n      attempts++;\n      \n      try {\n        // Try to fetch the URL - if SSL works, this will succeed\n        const response = await fetch(url, { \n          method: 'HEAD',\n          mode: 'no-cors' // Avoid CORS issues\n        });\n        \n        // If we get here, SSL is working\n        showNotification(`\u2705 ${appName} is ready! SSL certificate generated.`, 'success', 5000);\n        return true;\n      } catch (error) {\n        // SSL not ready yet\n        if (attempts < maxAttempts) {\n          setTimeout(checkCert, 5000); // Check again in 5 seconds\n        } else {\n          showNotification(\n            `\u26A0\uFE0F ${appName} deployed but SSL certificate may still be generating.\\nTry refreshing in a moment if you see a certificate error.`,\n            'warning',\n            10000\n          );\n        }\n        return false;\n      }\n    };\n    \n    // Start checking after 3 seconds (give Caddy time to start)\n    setTimeout(checkCert, 3000);\n  }\n\n  // Load custom apps on startup\n  function loadCustomApps() {\n    const customApps = safeGetJSON(APPS_KEY, []);\n    customApps.forEach(app => {\n      if (!window.APPS.some(a => a.id === app.id)) {\n        window.APPS.push(app);\n      }\n    });\n  }\n\n  // Event listeners\n  document.getElementById('add-service-btn')?.addEventListener('click', () => {\n    buildAppSelector();\n    modal.classList.add('show');\n  });\n\n  wireModal(modal, document.getElementById('app-selector-cancel'));\n\n  // Deploy modal event listeners\n  const deployModal = document.getElementById('app-deploy-modal');\n\n  document.getElementById('app-deploy-cancel')?.addEventListener('click', () => {\n    deployModal.classList.remove('show');\n  });\n\n  document.getElementById('app-deploy-confirm')?.addEventListener('click', () => {\n    // Get user configuration\n    const appTemplate = JSON.parse(deployModal.dataset.appTemplate);\n    const mediaPath = document.getElementById('deploy-media-path').value.trim();\n\n    // Collect custom volume overrides\n    const customVolumes = [];\n    document.querySelectorAll('#volume-mounts-list .vol-host-path').forEach(input => {\n      customVolumes.push({ hostPath: input.value.trim(), containerPath: input.dataset.containerPath });\n    });\n\n    const deployConfig = {\n      appTemplate: appTemplate,\n      subdomain: document.getElementById('deploy-subdomain').value.trim(),\n      dnsType: document.querySelector('input[name=\"dns-type\"]:checked').value,\n      sslType: document.querySelector('input[name=\"ssl-type\"]:checked').value,\n      ip: document.getElementById('deploy-ip').value.trim(),\n      port: document.getElementById('deploy-port').value.trim(),\n      tailscaleOnly: document.getElementById('deploy-tailscale-only').checked,\n      mediaPath: mediaPath || null,\n      plexClaimToken: document.getElementById('deploy-plex-claim')?.value.trim() || null,\n      customVolumes: customVolumes.length > 0 ? customVolumes : null,\n      resources: {\n        cpus: parseFloat(document.getElementById('deploy-cpu-limit').value) || 0,\n        memory: parseFloat(document.getElementById('deploy-memory-limit').value) || 0,\n      }\n    };\n\n    // Validate subdomain\n    if (!deployConfig.subdomain) {\n      showNotification('Please enter a subdomain or domain name', 'warning');\n      return;\n    }\n\n    // Validate media path for media apps\n    if (appTemplate.mediaMount?.required && !mediaPath) {\n      showNotification('Please enter a media library path for this application', 'warning');\n      return;\n    }\n\n    // Close deploy modal\n    deployModal.classList.remove('show');\n\n    // Start deployment\n    addAppToGrid(deployConfig);\n  });\n\n  wireModal(deployModal);\n\n  // ===== FOLDER BROWSER FUNCTIONALITY =====\n  const folderBrowserModal = document.getElementById('folder-browser-modal');\n  const folderBrowserPath = document.getElementById('folder-browser-path');\n  const folderBrowserList = document.getElementById('folder-browser-list');\n  const folderBrowserSelected = document.getElementById('folder-browser-selected');\n  const folderBrowserSelectedList = document.getElementById('folder-browser-selected-list');\n  let currentBrowserPath = '';\n  let selectedFolders = [];\n  let targetMediaInput = null;\n\n  window.openFolderBrowser = function(mediaInput) {\n    targetMediaInput = mediaInput;\n    selectedFolders = mediaInput.value.split(',').map(p => p.trim()).filter(p => p);\n    currentBrowserPath = '';\n    updateSelectedFoldersDisplay();\n    loadFolderContents('');\n    folderBrowserModal.classList.add('show');\n  };\n\n  async function loadFolderContents(path) {\n    folderBrowserPath.textContent = path || 'Select a drive...';\n    folderBrowserList.innerHTML = '<div style=\"padding: 20px; text-align: center; color: var(--muted);\">Loading...</div>';\n\n    try {\n      const response = await fetch(`/api/v1/browse/directories?path=${encodeURIComponent(path)}`);\n      const result = await response.json();\n\n      if (!result.success) {\n        folderBrowserList.innerHTML = `<div style=\"padding: 20px; text-align: center; color: var(--error);\">Error: ${escapeHtml(result.error)}</div>`;\n        return;\n      }\n\n      currentBrowserPath = result.path || '';\n      folderBrowserPath.textContent = currentBrowserPath || 'Select a drive...';\n\n      let html = '';\n\n      // Add parent folder navigation\n      if (result.parent && result.parent !== result.path) {\n        html += `<div class=\"folder-item\" data-path=\"${escapeHtml(result.parent)}\" style=\"padding: 12px 16px; border-bottom: 1px solid var(--border); cursor: pointer; display: flex; align-items: center; gap: 10px;\">\n          <span style=\"font-size: 1.2rem;\">\u2B06\uFE0F</span>\n          <span style=\"color: var(--muted);\">.. Parent Directory</span>\n        </div>`;\n      }\n\n      // Add folders\n      if (result.items.length === 0 && !result.parent) {\n        html += '<div style=\"padding: 20px; text-align: center; color: var(--muted);\">No browseable drives configured. Check your docker-compose.yml volume mounts.</div>';\n      } else if (result.items.length === 0) {\n        html += '<div style=\"padding: 20px; text-align: center; color: var(--muted);\">No subfolders found</div>';\n      } else {\n        result.items.forEach(item => {\n          const icon = item.type === 'drive' ? '\uD83D\uDCBE' : '\uD83D\uDCC1';\n          const isSelected = selectedFolders.includes(item.path);\n          const selectedStyle = isSelected ? 'background: color-mix(in srgb, var(--success) 20%, transparent);' : '';\n          html += `<div class=\"folder-item\" data-path=\"${escapeHtml(item.path)}\" style=\"padding: 12px 16px; border-bottom: 1px solid var(--border); cursor: pointer; display: flex; align-items: center; gap: 10px; ${selectedStyle}\">\n            <span style=\"font-size: 1.2rem;\">${icon}</span>\n            <span style=\"flex: 1;\">${escapeHtml(item.name)}</span>\n            ${isSelected ? '<span style=\"color: var(--success);\">\u2713</span>' : ''}\n          </div>`;\n        });\n      }\n\n      folderBrowserList.innerHTML = html;\n\n      // Add click handlers\n      folderBrowserList.querySelectorAll('.folder-item').forEach(item => {\n        item.addEventListener('click', () => {\n          loadFolderContents(item.dataset.path);\n        });\n        item.addEventListener('mouseenter', () => {\n          item.style.background = 'var(--card-bg)';\n        });\n        item.addEventListener('mouseleave', () => {\n          const isSelected = selectedFolders.includes(item.dataset.path);\n          item.style.background = isSelected ? 'color-mix(in srgb, var(--success) 20%, transparent)' : '';\n        });\n      });\n\n    } catch (error) {\n      folderBrowserList.innerHTML = `<div style=\"padding: 20px; text-align: center; color: var(--error);\">Failed to load: ${escapeHtml(error.message)}</div>`;\n    }\n  }\n\n  function updateSelectedFoldersDisplay() {\n    if (selectedFolders.length === 0) {\n      folderBrowserSelected.style.display = 'none';\n      return;\n    }\n    folderBrowserSelected.style.display = 'block';\n    folderBrowserSelectedList.innerHTML = selectedFolders.map(path => `\n      <span style=\"padding: 6px 12px; background: var(--card-bg); border: 1px solid var(--success); border-radius: 4px; display: flex; align-items: center; gap: 6px;\">\n        ${escapeHtml(path)}\n        <button type=\"button\" onclick=\"removeSelectedFolder('${escapeHtml(path)}')\" style=\"background: none; border: none; cursor: pointer; color: var(--error); font-size: 1rem; padding: 0;\">\u00D7</button>\n      </span>\n    `).join('');\n  }\n\n  window.removeSelectedFolder = function(path) {\n    selectedFolders = selectedFolders.filter(p => p !== path);\n    updateSelectedFoldersDisplay();\n    loadFolderContents(currentBrowserPath); // Refresh to update checkmarks\n  };\n\n  document.getElementById('folder-browser-select-current').addEventListener('click', () => {\n    if (currentBrowserPath && !selectedFolders.includes(currentBrowserPath)) {\n      selectedFolders.push(currentBrowserPath);\n      updateSelectedFoldersDisplay();\n      loadFolderContents(currentBrowserPath); // Refresh to show checkmark\n    }\n  });\n\n  wireModal(folderBrowserModal, document.getElementById('folder-browser-cancel'));\n\n  document.getElementById('folder-browser-done').addEventListener('click', () => {\n    if (targetMediaInput) {\n      targetMediaInput.value = selectedFolders.join(', ');\n    }\n    folderBrowserModal.classList.remove('show');\n  });\n\n  // Load custom apps on page load\n  loadCustomApps();\n})();\n;\n// Recipe System \u2014 multi-container stack deployment\n(function() {\n  // === RECIPE DEPLOY WIZARD MODAL ===\n  injectModal('recipe-deploy-modal', `<div id=\"recipe-deploy-modal\" class=\"weather-modal\">\n    <div class=\"weather-modal-content\" style=\"min-width: 620px; max-width: 740px;\">\n      <h3 id=\"recipe-deploy-title\">Deploy Recipe</h3>\n\n      <!-- Step indicator -->\n      <div id=\"recipe-steps\" style=\"display: flex; gap: 4px; margin: 16px 0 24px;\">\n        <div class=\"recipe-step active\" data-step=\"1\"><span>1</span> Components</div>\n        <div class=\"recipe-step\" data-step=\"2\"><span>2</span> Configuration</div>\n        <div class=\"recipe-step\" data-step=\"3\"><span>3</span> Review</div>\n        <div class=\"recipe-step\" data-step=\"4\"><span>4</span> Progress</div>\n      </div>\n\n      <!-- Step 1: Component Selection -->\n      <div id=\"recipe-step-1\" class=\"recipe-step-panel\">\n        <label class=\"form-label-accent-sm\">Select Components:</label>\n        <div id=\"recipe-component-list\" style=\"display: grid; gap: 10px; margin-top: 8px;\"></div>\n      </div>\n\n      <!-- Step 2: Shared Configuration -->\n      <div id=\"recipe-step-2\" class=\"recipe-step-panel\" style=\"display:none;\">\n        <div style=\"display: grid; gap: 16px;\">\n          <!-- Shared volumes -->\n          <div id=\"recipe-volumes-section\" style=\"display:none;\">\n            <label class=\"form-label-accent-sm\">Shared Volumes:</label>\n            <div id=\"recipe-volume-list\" style=\"display: grid; gap: 10px; margin-top: 8px;\"></div>\n          </div>\n\n          <!-- Timezone -->\n          <div>\n            <label class=\"form-label-accent-sm\">Timezone:</label>\n            <input type=\"text\" id=\"recipe-timezone\" value=\"UTC\" placeholder=\"e.g. America/New_York\"\n              style=\"width: 100%; padding: 8px 12px; background: var(--card-bg); color: var(--fg); border: 1px solid var(--border); border-radius: 6px;\" />\n          </div>\n\n          <!-- Target IP -->\n          <div>\n            <label class=\"form-label-accent-sm\">Target IP Address:</label>\n            <input type=\"text\" id=\"recipe-ip\" value=\"host.docker.internal\" placeholder=\"localhost or IP\"\n              style=\"width: 100%; padding: 8px 12px; background: var(--card-bg); color: var(--fg); border: 1px solid var(--border); border-radius: 6px;\" />\n            <div class=\"form-hint-sm\">IP where containers expose ports</div>\n          </div>\n\n          <!-- Tailscale -->\n          <label class=\"checkbox-label\">\n            <input type=\"checkbox\" id=\"recipe-tailscale\" />\n            <span>Restrict to Tailscale network only</span>\n          </label>\n        </div>\n      </div>\n\n      <!-- Step 3: Review -->\n      <div id=\"recipe-step-3\" class=\"recipe-step-panel\" style=\"display:none;\">\n        <div id=\"recipe-review-content\" style=\"font-size: 0.9rem; line-height: 1.7;\"></div>\n      </div>\n\n      <!-- Step 4: Progress -->\n      <div id=\"recipe-step-4\" class=\"recipe-step-panel\" style=\"display:none;\">\n        <div id=\"recipe-progress-list\" style=\"display: grid; gap: 8px;\"></div>\n        <div id=\"recipe-deploy-result\" style=\"margin-top: 16px; display:none;\"></div>\n      </div>\n\n      <div class=\"weather-modal-buttons\" style=\"margin-top: 20px;\">\n        <button id=\"recipe-cancel\">Cancel</button>\n        <button id=\"recipe-prev\" class=\"btn-accent\" style=\"display:none;\">Back</button>\n        <button id=\"recipe-next\" class=\"btn-accent-solid\">Next</button>\n      </div>\n    </div>\n  </div>`);\n\n  // === STATE ===\n  let recipeTemplates = null;\n  let recipeCategories = null;\n  let currentRecipe = null;\n  let currentStep = 1;\n  let isPremium = false;\n\n  const deployModal = document.getElementById('recipe-deploy-modal');\n  const cancelBtn = document.getElementById('recipe-cancel');\n  const prevBtn = document.getElementById('recipe-prev');\n  const nextBtn = document.getElementById('recipe-next');\n\n  wireModal(deployModal, cancelBtn);\n\n  // === FETCH RECIPE TEMPLATES ===\n  async function fetchRecipeTemplates() {\n    try {\n      const resp = await fetch('/api/v1/recipes/templates');\n      const data = await resp.json();\n      if (data.success) {\n        recipeTemplates = data.templates;\n        recipeCategories = data.categories;\n        return true;\n      }\n      // Premium required \u2014 templates API gated\n      if (resp.status === 403) {\n        isPremium = false;\n        return false;\n      }\n    } catch (e) {\n      console.warn('Failed to fetch recipe templates:', e.message);\n    }\n    return false;\n  }\n\n  // === CHECK PREMIUM ===\n  async function checkRecipePremium() {\n    try {\n      const resp = await fetch('/api/v1/license/feature/recipes');\n      const data = await resp.json();\n      isPremium = data.available;\n    } catch {\n      isPremium = false;\n    }\n    return isPremium;\n  }\n\n  // === RENDER RECIPE CARDS INTO APP SELECTOR ===\n  // This function is called by the app selector to inject recipe cards\n  window.renderRecipeCards = async function(grid) {\n    await checkRecipePremium();\n\n    // Build recipe data \u2014 we can show card metadata even without premium\n    // (cards just show a lock and prompt to upgrade)\n    let recipes;\n    if (isPremium && recipeTemplates) {\n      recipes = recipeTemplates;\n    } else {\n      // Show hardcoded preview cards when not premium\n      recipes = getPreviewRecipes();\n    }\n\n    if (!recipes || recipes.length === 0) return;\n\n    // Category header\n    const header = document.createElement('div');\n    header.className = 'app-category-header';\n    header.innerHTML = `\\uD83E\\uDDEA Recipes`;\n    header.style.borderBottomColor = '#8e44ad';\n    grid.appendChild(header);\n\n    const recipeList = Array.isArray(recipes) ? recipes : Object.values(recipes);\n    recipeList.sort((a, b) => (b.popularity || 0) - (a.popularity || 0));\n\n    for (const recipe of recipeList) {\n      const option = document.createElement('div');\n      option.className = 'app-option';\n      option.style.position = 'relative';\n\n      const componentBadge = `<div style=\"font-size: 0.65rem; padding: 2px 6px; border-radius: 4px; margin-top: 4px; background: rgba(142,68,173,0.2); color: #a855f7;\">${recipe.componentCount || recipe.components?.length || '?'} apps</div>`;\n\n      const lockOverlay = !isPremium ? `<div style=\"position: absolute; top: 6px; right: 6px; font-size: 0.65rem; padding: 2px 8px; border-radius: 10px; background: rgba(241,196,15,0.2); color: #f1c40f; font-weight: 600;\">PREMIUM</div>` : '';\n\n      option.innerHTML = `\n        ${lockOverlay}\n        <div class=\"app-option-icon\">${escapeHtml(recipe.icon || '\\uD83E\\uDDEA')}</div>\n        <div class=\"app-option-name\">${escapeHtml(recipe.name)}</div>\n        <div class=\"app-option-desc\">${escapeHtml(recipe.description || '')}</div>\n        ${componentBadge}\n      `;\n\n      option.onclick = () => {\n        if (!isPremium) {\n          showNotification('Recipes require a DashCaddy Premium license. Click the License button to activate.', 'warning', 5000);\n          if (window.openLicenseModal) window.openLicenseModal();\n          return;\n        }\n        openRecipeDeployWizard(recipe);\n      };\n\n      grid.appendChild(option);\n    }\n  };\n\n  function getPreviewRecipes() {\n    return [\n      { id: 'htpc-suite', name: 'HTPC Suite', icon: '\\uD83C\\uDFAC', description: 'Complete media automation: find, download, organize, and stream', componentCount: 6, popularity: 98 },\n      { id: 'nextcloud-complete', name: 'Nextcloud Complete', icon: '\\u2601\\uFE0F', description: 'Full productivity suite: cloud storage, office editing, and collaboration', componentCount: 4, popularity: 90 },\n      { id: 'smart-home', name: 'Smart Home Hub', icon: '\\uD83C\\uDFE0', description: 'Home automation: control, automate, and monitor IoT devices', componentCount: 4, popularity: 88 },\n      { id: 'dev-environment', name: 'Dev Environment', icon: '\\uD83D\\uDCBB', description: 'Self-hosted development workflow: Git, CI/CD, IDE, and database', componentCount: 4, popularity: 82 }\n    ];\n  }\n\n  // === RECIPE DEPLOY WIZARD ===\n  function openRecipeDeployWizard(recipe) {\n    currentRecipe = recipe;\n    currentStep = 1;\n\n    // Close app selector\n    const appSelectorModal = document.getElementById('app-selector-modal');\n    if (appSelectorModal) appSelectorModal.classList.remove('show');\n\n    document.getElementById('recipe-deploy-title').textContent = `Deploy ${recipe.name}`;\n\n    // Reset steps\n    updateStepUI();\n    renderStep1();\n\n    deployModal.classList.add('show');\n  }\n\n  function updateStepUI() {\n    // Step indicators\n    document.querySelectorAll('#recipe-steps .recipe-step').forEach(el => {\n      const step = parseInt(el.dataset.step);\n      el.classList.toggle('active', step === currentStep);\n      el.classList.toggle('completed', step < currentStep);\n    });\n\n    // Step panels\n    for (let i = 1; i <= 4; i++) {\n      const panel = document.getElementById(`recipe-step-${i}`);\n      if (panel) panel.style.display = i === currentStep ? '' : 'none';\n    }\n\n    // Navigation buttons\n    prevBtn.style.display = currentStep > 1 && currentStep < 4 ? '' : 'none';\n    if (currentStep === 4) {\n      nextBtn.style.display = 'none';\n      cancelBtn.textContent = 'Close';\n    } else if (currentStep === 3) {\n      nextBtn.textContent = '\\uD83D\\uDE80 Deploy';\n      nextBtn.style.display = '';\n      cancelBtn.textContent = 'Cancel';\n    } else {\n      nextBtn.textContent = 'Next';\n      nextBtn.style.display = '';\n      cancelBtn.textContent = 'Cancel';\n    }\n  }\n\n  // Step 1: Component selection\n  function renderStep1() {\n    const list = document.getElementById('recipe-component-list');\n    list.innerHTML = '';\n\n    const components = currentRecipe.components || [];\n    for (const comp of components) {\n      const el = document.createElement('div');\n      el.style.cssText = 'display: flex; align-items: center; gap: 12px; padding: 12px; border-radius: 8px; background: var(--card-bg); border: 1px solid var(--border);';\n\n      const isRequired = comp.required;\n      const isInternal = comp.internal;\n\n      el.innerHTML = `\n        <input type=\"checkbox\" ${isRequired ? 'checked disabled' : 'checked'} data-component-id=\"${comp.id}\"\n          style=\"width: 18px; height: 18px; accent-color: var(--accent);\" />\n        <div style=\"flex: 1;\">\n          <div style=\"font-weight: 600; font-size: 0.9rem;\">${escapeHtml(comp.role || comp.id)}</div>\n          <div style=\"font-size: 0.78rem; color: var(--muted);\">\n            ${comp.templateRef ? escapeHtml(comp.templateRef) : 'Built-in'}\n            ${isRequired ? '<span style=\"color: var(--accent); margin-left: 6px;\">Required</span>' : '<span style=\"color: var(--muted); margin-left: 6px;\">Optional</span>'}\n            ${isInternal ? '<span style=\"color: var(--muted); margin-left: 6px;\">(Internal)</span>' : ''}\n          </div>\n          ${comp.note ? `<div style=\"font-size: 0.75rem; color: var(--warn-fg); margin-top: 4px;\">\\u26A0 ${escapeHtml(comp.note)}</div>` : ''}\n        </div>\n      `;\n      list.appendChild(el);\n    }\n  }\n\n  // Step 2: Shared configuration\n  function renderStep2() {\n    const volumeSection = document.getElementById('recipe-volumes-section');\n    const volumeList = document.getElementById('recipe-volume-list');\n\n    const sharedVolumes = currentRecipe.sharedVolumes;\n    if (sharedVolumes && Object.keys(sharedVolumes).length > 0) {\n      volumeSection.style.display = '';\n      volumeList.innerHTML = '';\n\n      for (const [key, vol] of Object.entries(sharedVolumes)) {\n        const el = document.createElement('div');\n        el.style.cssText = 'display: grid; gap: 4px;';\n        el.innerHTML = `\n          <label style=\"font-weight: 500; font-size: 0.85rem;\">${escapeHtml(vol.label || key)}</label>\n          <input type=\"text\" data-volume-key=\"${key}\" value=\"${escapeHtml(vol.defaultPath || '')}\"\n            placeholder=\"${escapeHtml(vol.defaultPath || '/path')}\"\n            style=\"width: 100%; padding: 8px 12px; background: var(--card-bg); color: var(--fg); border: 1px solid var(--border); border-radius: 6px; font-family: monospace; font-size: 0.85rem;\" />\n          <div class=\"form-hint-sm\">${escapeHtml(vol.description || '')}</div>\n        `;\n        volumeList.appendChild(el);\n      }\n    } else {\n      volumeSection.style.display = 'none';\n    }\n  }\n\n  // Step 3: Review\n  function renderStep3() {\n    const content = document.getElementById('recipe-review-content');\n    const selectedComponents = getSelectedComponents();\n\n    const volumeInputs = document.querySelectorAll('#recipe-volume-list input[data-volume-key]');\n    const volumes = {};\n    volumeInputs.forEach(input => {\n      volumes[input.dataset.volumeKey] = input.value;\n    });\n\n    const tz = document.getElementById('recipe-timezone').value || 'UTC';\n    const ip = document.getElementById('recipe-ip').value || 'host.docker.internal';\n    const tailscale = document.getElementById('recipe-tailscale').checked;\n\n    content.innerHTML = `\n      <div style=\"font-weight: 600; font-size: 1rem; margin-bottom: 12px;\">${escapeHtml(currentRecipe.name)}</div>\n      <div style=\"color: var(--muted); margin-bottom: 16px;\">${escapeHtml(currentRecipe.description || '')}</div>\n\n      <div style=\"margin-bottom: 12px;\">\n        <strong>Components (${selectedComponents.length}):</strong>\n        <div style=\"display: grid; gap: 4px; margin-top: 6px;\">\n          ${selectedComponents.map(c => `<div style=\"padding: 4px 0; font-size: 0.85rem;\">\n            \\u2022 <strong>${escapeHtml(c.role || c.id)}</strong> ${c.internal ? '<span style=\"color:var(--muted)\">(internal)</span>' : ''}\n          </div>`).join('')}\n        </div>\n      </div>\n\n      ${Object.keys(volumes).length > 0 ? `<div style=\"margin-bottom: 12px;\">\n        <strong>Volumes:</strong>\n        ${Object.entries(volumes).map(([k, v]) => `<div style=\"font-size: 0.85rem; font-family: monospace; color: var(--muted);\">${k}: ${escapeHtml(v)}</div>`).join('')}\n      </div>` : ''}\n\n      <div style=\"font-size: 0.85rem; color: var(--muted);\">\n        Timezone: ${escapeHtml(tz)} &bull; IP: ${escapeHtml(ip)} ${tailscale ? '&bull; Tailscale only' : ''}\n      </div>\n\n      ${currentRecipe.network ? `<div style=\"font-size: 0.85rem; color: var(--muted); margin-top: 4px;\">Docker network: <code>${escapeHtml(currentRecipe.network.name)}</code></div>` : ''}\n    `;\n  }\n\n  function getSelectedComponents() {\n    const checkboxes = document.querySelectorAll('#recipe-component-list input[data-component-id]');\n    const selectedIds = new Set();\n    checkboxes.forEach(cb => {\n      if (cb.checked) selectedIds.add(cb.dataset.componentId);\n    });\n\n    // Always include required components\n    const components = currentRecipe.components || [];\n    components.filter(c => c.required).forEach(c => selectedIds.add(c.id));\n\n    return components.filter(c => selectedIds.has(c.id));\n  }\n\n  // Step 4: Deploy\n  async function executeDeploy() {\n    const progressList = document.getElementById('recipe-progress-list');\n    const resultEl = document.getElementById('recipe-deploy-result');\n    resultEl.style.display = 'none';\n    progressList.innerHTML = '';\n\n    const selectedComponents = getSelectedComponents();\n\n    // Show progress items\n    for (const comp of selectedComponents) {\n      const el = document.createElement('div');\n      el.id = `recipe-progress-${comp.id}`;\n      el.style.cssText = 'display: flex; align-items: center; gap: 10px; padding: 10px 12px; border-radius: 6px; background: var(--card-bg); border: 1px solid var(--border); font-size: 0.85rem;';\n      el.innerHTML = `\n        <span class=\"recipe-progress-icon\" style=\"font-size: 1.1rem;\">\\u23F3</span>\n        <span style=\"flex:1; font-weight: 500;\">${escapeHtml(comp.role || comp.id)}</span>\n        <span class=\"recipe-progress-status\" style=\"color: var(--muted);\">Queued</span>\n      `;\n      progressList.appendChild(el);\n    }\n\n    // Collect config\n    const volumeInputs = document.querySelectorAll('#recipe-volume-list input[data-volume-key]');\n    const volumes = {};\n    volumeInputs.forEach(input => {\n      volumes[input.dataset.volumeKey] = input.value;\n    });\n\n    const config = {\n      selectedComponents: selectedComponents.map(c => c.id),\n      sharedConfig: {\n        ip: document.getElementById('recipe-ip').value || 'host.docker.internal',\n        timezone: document.getElementById('recipe-timezone').value || 'UTC',\n        tailscaleOnly: document.getElementById('recipe-tailscale').checked,\n        volumes\n      },\n      componentOverrides: {}\n    };\n\n    // Mark all as deploying\n    for (const comp of selectedComponents) {\n      updateProgressItem(comp.id, 'deploying', 'Deploying...');\n    }\n\n    try {\n      const resp = await secureFetch('/api/v1/recipes/deploy', {\n        method: 'POST',\n        headers: { 'Content-Type': 'application/json' },\n        body: JSON.stringify({ recipeId: currentRecipe.id, config })\n      });\n      const data = await resp.json();\n\n      if (data.success) {\n        // Mark deployed components\n        for (const deployed of (data.deployed || [])) {\n          updateProgressItem(deployed.id, 'success', deployed.url ? `Running \\u2192 ${deployed.url}` : 'Running');\n        }\n        // Mark errors\n        for (const err of (data.errors || [])) {\n          updateProgressItem(err.componentId, 'error', err.error);\n        }\n\n        resultEl.style.display = '';\n        resultEl.innerHTML = `\n          <div style=\"padding: 14px; border-radius: 8px; background: rgba(46,204,113,0.1); border: 1px solid rgba(46,204,113,0.3);\">\n            <div style=\"font-weight: 600; color: var(--ok-fg); margin-bottom: 6px;\">${escapeHtml(data.message || 'Deployed!')}</div>\n            ${data.setupInstructions ? `<div style=\"font-size: 0.8rem; color: var(--muted); margin-top: 8px;\">\n              <strong>Setup tips:</strong>\n              <ul style=\"margin: 4px 0 0 16px; padding: 0;\">${data.setupInstructions.map(s => `<li>${escapeHtml(s)}</li>`).join('')}</ul>\n            </div>` : ''}\n          </div>\n        `;\n\n        showNotification(`${currentRecipe.name} recipe deployed successfully!`, 'success', 5000);\n\n        // Refresh dashboard\n        if (window.loadServices) window.loadServices();\n      } else {\n        resultEl.style.display = '';\n        resultEl.innerHTML = `<div style=\"padding: 14px; border-radius: 8px; background: rgba(231,76,60,0.1); border: 1px solid rgba(231,76,60,0.3); color: var(--bad-fg);\">\n          <strong>Deployment failed:</strong> ${escapeHtml(data.error || 'Unknown error')}\n        </div>`;\n        showNotification(`Recipe deployment failed: ${data.error}`, 'error', 5000);\n      }\n    } catch (e) {\n      resultEl.style.display = '';\n      resultEl.innerHTML = `<div style=\"padding: 14px; border-radius: 8px; background: rgba(231,76,60,0.1); border: 1px solid rgba(231,76,60,0.3); color: var(--bad-fg);\">\n        <strong>Network error:</strong> ${escapeHtml(e.message)}\n      </div>`;\n    }\n  }\n\n  function updateProgressItem(componentId, status, text) {\n    const el = document.getElementById(`recipe-progress-${componentId}`);\n    if (!el) return;\n    const icon = el.querySelector('.recipe-progress-icon');\n    const statusEl = el.querySelector('.recipe-progress-status');\n\n    if (status === 'deploying') {\n      icon.textContent = '\\u23F3';\n      statusEl.style.color = 'var(--accent)';\n    } else if (status === 'success') {\n      icon.textContent = '\\u2705';\n      statusEl.style.color = 'var(--ok-fg)';\n    } else if (status === 'error') {\n      icon.textContent = '\\u274C';\n      statusEl.style.color = 'var(--bad-fg)';\n    }\n    statusEl.textContent = text;\n  }\n\n  // === STEP NAVIGATION ===\n  nextBtn.addEventListener('click', () => {\n    if (currentStep === 3) {\n      currentStep = 4;\n      updateStepUI();\n      executeDeploy();\n      return;\n    }\n    if (currentStep < 3) {\n      currentStep++;\n      updateStepUI();\n      if (currentStep === 2) renderStep2();\n      if (currentStep === 3) renderStep3();\n    }\n  });\n\n  prevBtn.addEventListener('click', () => {\n    if (currentStep > 1 && currentStep < 4) {\n      currentStep--;\n      updateStepUI();\n    }\n  });\n\n  // === RECIPE CARD GROUPING ON DASHBOARD ===\n  // After dashboard loads, group cards that share a recipeId\n  window.groupRecipeCards = function() {\n    const cards = document.querySelectorAll('.service-card[data-recipe-id]');\n    if (cards.length === 0) return;\n\n    const groups = {};\n    cards.forEach(card => {\n      const recipeId = card.dataset.recipeId;\n      if (!groups[recipeId]) groups[recipeId] = [];\n      groups[recipeId].push(card);\n    });\n\n    for (const [recipeId, groupCards] of Object.entries(groups)) {\n      if (groupCards.length < 2) continue;\n\n      // Apply subtle visual grouping\n      groupCards.forEach((card, i) => {\n        card.style.borderLeft = '3px solid rgba(142,68,173,0.5)';\n        if (i === 0) {\n          // Add a recipe label to the first card\n          let label = card.querySelector('.recipe-group-label');\n          if (!label) {\n            label = document.createElement('div');\n            label.className = 'recipe-group-label';\n            label.style.cssText = 'position: absolute; top: -8px; left: 12px; font-size: 0.6rem; padding: 1px 8px; border-radius: 8px; background: rgba(142,68,173,0.3); color: #d4a5ff; font-weight: 600; text-transform: uppercase; letter-spacing: 0.5px;';\n            label.textContent = recipeId.replace(/-/g, ' ');\n            card.style.position = 'relative';\n            card.appendChild(label);\n          }\n        }\n      });\n    }\n  };\n\n  // === RECIPE MANAGEMENT ACTIONS ===\n  window.manageRecipe = async function(recipeId, action) {\n    const endpoint = `/api/v1/recipes/${recipeId}/${action}`;\n    const method = action === 'remove' ? 'DELETE' : 'POST';\n    const url = action === 'remove' ? `/api/v1/recipes/${recipeId}` : endpoint;\n\n    if (action === 'remove' && !confirm(`Remove the entire ${recipeId} recipe? This will delete all containers and configuration.`)) {\n      return;\n    }\n\n    try {\n      const resp = await secureFetch(url, { method });\n      const data = await resp.json();\n      if (data.success) {\n        showNotification(`Recipe ${action}: ${data.results?.filter(r => r.status !== 'failed').length || 0} components processed`, 'success', 4000);\n        if (window.loadServices) window.loadServices();\n      } else {\n        showNotification(`Recipe ${action} failed: ${data.error}`, 'error', 5000);\n      }\n    } catch (e) {\n      showNotification(`Network error: ${e.message}`, 'error', 5000);\n    }\n  };\n\n  // === INJECT CSS ===\n  const style = document.createElement('style');\n  style.textContent = `\n    .recipe-step {\n      flex: 1;\n      text-align: center;\n      padding: 8px 4px;\n      font-size: 0.78rem;\n      color: var(--muted);\n      border-bottom: 2px solid var(--border);\n      transition: all 0.2s;\n    }\n    .recipe-step span {\n      display: inline-flex;\n      align-items: center;\n      justify-content: center;\n      width: 20px;\n      height: 20px;\n      border-radius: 50%;\n      background: var(--border);\n      color: var(--muted);\n      font-size: 0.7rem;\n      font-weight: 700;\n      margin-right: 4px;\n    }\n    .recipe-step.active {\n      color: var(--accent);\n      border-bottom-color: var(--accent);\n    }\n    .recipe-step.active span {\n      background: var(--accent);\n      color: #fff;\n    }\n    .recipe-step.completed {\n      color: var(--ok-fg);\n      border-bottom-color: var(--ok-fg);\n    }\n    .recipe-step.completed span {\n      background: var(--ok-fg);\n      color: #fff;\n    }\n    .recipe-step-panel {\n      min-height: 180px;\n    }\n  `;\n  document.head.appendChild(style);\n\n  // === INIT ===\n  // Pre-fetch premium status on load\n  checkRecipePremium();\n})();\n;\n// ========== CADDY RELOAD BUTTON ==========\n(function() {\n  // Reload Caddy button handler\n  document.getElementById('reload-caddy-top')?.addEventListener('click', async () => {\n    const button = document.getElementById('reload-caddy-top');\n    const originalText = button.textContent;\n\n    try {\n      button.textContent = '\u23F3 Reloading...';\n      button.disabled = true;\n\n      const response = await secureFetch('/api/v1/caddy/reload', {\n        method: 'POST',\n        headers: { 'Content-Type': 'application/json' }\n      });\n\n      const result = await response.json();\n\n      if (response.ok && result.success) {\n        button.textContent = '\u2705 Reloaded!';\n        setTimeout(() => {\n          button.textContent = originalText;\n          button.disabled = false;\n        }, 2000);\n      } else {\n        throw new Error(result.error || 'Reload failed');\n      }\n    } catch (error) {\n      button.textContent = '\u274C Failed';\n      showNotification(`Failed to reload Caddy: ${error.message}`, 'error');\n      setTimeout(() => {\n        button.textContent = originalText;\n        button.disabled = false;\n      }, 2000);\n    }\n  });\n})();\n;\n// ========== ERROR LOG VIEWER (DC-052) ==========\n// DC-052: Adds Level / Context / Search / Time-range filters, server-side\n// pagination with Load More, click-to-expand stack frames, and a distinct\n// contexts dropdown backed by /api/v1/error-logs/contexts. Mirrors the\n// audit-log UX (DC-050) so operators can drill into a subsystem as easily\n// as they can audit who-did-what.\n(function() {\n  // Inject modal HTML. Same weather-modal shell as audit-log so styles\n  // are shared; wider min-width because error stacks need room to breathe.\n  injectModal('error-log-modal', `<div id=\"error-log-modal\" class=\"weather-modal\">\n    <div class=\"weather-modal-content\" style=\"min-width: 950px; max-width: 1150px;\">\n      <h3>\uD83D\uDCCB Error Logs</h3>\n      <p class=\"modal-subtitle\">\n        Errors and warnings from the DashCaddy API. Click a row to see the full stack trace.\n      </p>\n\n      <div style=\"display: flex; gap: 12px; margin-bottom: 12px; align-items: center; flex-wrap: wrap;\">\n        <label class=\"text-muted-sm\">Level:</label>\n        <select id=\"error-log-level\" style=\"padding: 6px 10px; border-radius: 6px; border: 1px solid var(--border); background: var(--bg); color: var(--fg); font-size: 0.85rem;\">\n          <option value=\"\">All</option>\n          <option value=\"ERR\">Errors</option>\n          <option value=\"WARN\">Warnings</option>\n          <option value=\"INFO\">Info</option>\n          <option value=\"DEBUG\">Debug</option>\n        </select>\n        <label class=\"text-muted-sm\">Context:</label>\n        <select id=\"error-log-context\" style=\"padding: 6px 10px; border-radius: 6px; border: 1px solid var(--border); background: var(--bg); color: var(--fg); font-size: 0.85rem; max-width: 220px;\">\n          <option value=\"\">All</option>\n        </select>\n        <label class=\"text-muted-sm\" style=\"margin-left: 8px;\">Search:</label>\n        <input id=\"error-log-search\" type=\"search\" placeholder=\"message / stack / ip\" style=\"padding: 5px 8px; border-radius: 6px; border: 1px solid var(--border); background: var(--bg); color: var(--fg); font-size: 0.82rem; min-width: 180px;\">\n        <label class=\"text-muted-sm\" style=\"margin-left: 8px;\">Since:</label>\n        <input id=\"error-log-since\" type=\"datetime-local\" style=\"padding: 5px 8px; border-radius: 6px; border: 1px solid var(--border); background: var(--bg); color: var(--fg); font-size: 0.82rem;\">\n        <label class=\"text-muted-sm\">Until:</label>\n        <input id=\"error-log-until\" type=\"datetime-local\" style=\"padding: 5px 8px; border-radius: 6px; border: 1px solid var(--border); background: var(--bg); color: var(--fg); font-size: 0.82rem;\">\n        <button id=\"error-log-refresh\" class=\"btn-sm\">\uD83D\uDD04 Refresh</button>\n        <span style=\"flex: 1;\"></span>\n        <button id=\"error-log-clear\" style=\"padding: 6px 12px; font-size: 0.8rem; color: var(--bad-fg); border-color: var(--bad-fg);\">\uD83D\uDDD1\uFE0F Clear Log</button>\n      </div>\n\n      <div id=\"error-log-container\" class=\"scroll-container\">\n        <div class=\"panel-empty\"><span class=\"brand-spinner\"></span> Loading error logs...</div>\n      </div>\n\n      <div style=\"margin-top: 12px; text-align: center;\">\n        <button id=\"error-log-load-more\" style=\"display: none; padding: 6px 16px; font-size: 0.8rem;\">Load More</button>\n      </div>\n\n      <div style=\"margin-top: 8px; font-size: 0.78rem; color: var(--muted); text-align: right;\">\n        <span id=\"error-log-total\"></span>\n      </div>\n\n      <div class=\"weather-modal-buttons modal-footer-bar\">\n        <button id=\"error-log-close\">Close</button>\n      </div>\n    </div>\n  </div>`);\n\n  const modal = document.getElementById('error-log-modal');\n  const viewBtn = document.getElementById('view-error-logs');\n  const refreshBtn = document.getElementById('error-log-refresh');\n  const clearBtn = document.getElementById('error-log-clear');\n  const closeBtn = document.getElementById('error-log-close');\n  const levelSel = document.getElementById('error-log-level');\n  const contextSel = document.getElementById('error-log-context');\n  const searchInput = document.getElementById('error-log-search');\n  const sinceInput = document.getElementById('error-log-since');\n  const untilInput = document.getElementById('error-log-until');\n  const container = document.getElementById('error-log-container');\n  const loadMoreBtn = document.getElementById('error-log-load-more');\n  const totalSpan = document.getElementById('error-log-total');\n\n  const PAGE_SIZE = 50;\n  let currentOffset = 0;\n  let inflight = null;\n  let filterNonce = 0;\n  // Cached distinct contexts so the dropdown is populated once per open and\n  // re-populated after a clear (which removes all contexts) or a refresh\n  // that surfaces a new subsystem for the first time.\n  let knownContexts = [];\n\n  // datetime-local fields are naive local time \u2014 convert to UTC ISO so the\n  // server compares correctly. Same shape as audit-log.js so the operator\n  // sees consistent behaviour between the two modals.\n  function toIso(localDtValue) {\n    if (!localDtValue) return null;\n    const d = new Date(localDtValue);\n    if (isNaN(d.getTime())) return null;\n    return d.toISOString();\n  }\n\n  // Pull the distinct contexts list once per open. Failures are silent\n  // (the dropdown will just show \"All\" only) so a transient backend hiccup\n  // doesn't block the operator from seeing the actual error rows.\n  async function refreshContexts() {\n    try {\n      const res = await fetch('/api/v1/error-logs/contexts');\n      if (!res.ok) return;\n      const data = await res.json();\n      if (!data.success || !Array.isArray(data.contexts)) return;\n      knownContexts = data.contexts;\n      const currentValue = contextSel.value;\n      contextSel.innerHTML = '<option value=\"\">All</option>';\n      for (const c of data.contexts) {\n        const opt = document.createElement('option');\n        opt.value = c.name;\n        opt.textContent = `${c.name} (${c.count})`;\n        contextSel.appendChild(opt);\n      }\n      // Restore previous selection if still present.\n      if (currentValue && data.contexts.some((c) => c.name === currentValue)) {\n        contextSel.value = currentValue;\n      }\n    } catch { /* ignore */ }\n  }\n\n  function buildQuery() {\n    const params = new URLSearchParams();\n    params.set('limit', String(PAGE_SIZE));\n    params.set('offset', String(currentOffset));\n    if (levelSel.value) params.set('level', levelSel.value);\n    if (contextSel.value) params.set('context', contextSel.value);\n    const since = toIso(sinceInput.value);\n    const until = toIso(untilInput.value);\n    if (since) params.set('since', since);\n    if (until) params.set('until', until);\n    const search = (searchInput.value || '').trim();\n    if (search) params.set('search', search);\n    return params;\n  }\n\n  async function loadLogs(append) {\n    try {\n      if (!append) {\n        if (inflight) inflight.abort();\n        inflight = new AbortController();\n        currentOffset = 0;\n        filterNonce++;\n        container.innerHTML = '<div class=\"panel-empty\"><span class=\"brand-spinner\"></span> Loading...</div>';\n      } else {\n        if (inflight) inflight.abort();\n        inflight = new AbortController();\n      }\n      const myNonce = filterNonce;\n      const params = buildQuery();\n\n      const res = await fetch('/api/v1/error-logs?' + params.toString(), {\n        signal: inflight.signal,\n      });\n      // Mirror audit-log: surface 4xx/5xx explicitly instead of falling\n      // through to a misleading \"no entries yet\" empty state.\n      if (!res.ok) {\n        container.innerHTML = `<div class=\"panel-empty\" style=\"color: var(--bad-fg);\">Failed: HTTP ${res.status}</div>`;\n        loadMoreBtn.style.display = 'none';\n        totalSpan.textContent = '';\n        return;\n      }\n      const data = await res.json();\n      if (!data.success) {\n        container.innerHTML = `<div class=\"panel-empty\" style=\"color: var(--bad-fg);\">Failed: ${escapeHtml(data.error || 'unknown')}</div>`;\n        loadMoreBtn.style.display = 'none';\n        totalSpan.textContent = '';\n        return;\n      }\n      // Stale-response guard: a non-append load happened after this fetch,\n      // discard so we don't splice into the wrong DOM.\n      if (!append && myNonce !== filterNonce) return;\n\n      const logs = Array.isArray(data.logs) ? data.logs : [];\n      if (logs.length === 0 && !append) {\n        const reason = (data.filters && (data.filters.level || data.filters.context || data.filters.search || data.filters.since || data.filters.until))\n          ? 'No error log entries match your filters.'\n          : '\u2705 No errors logged! Everything is working smoothly.';\n        container.innerHTML = `<div class=\"panel-empty\"><span class=\"empty-icon\">\uD83D\uDCCB</span>${escapeHtml(reason)}</div>`;\n        loadMoreBtn.style.display = 'none';\n        totalSpan.textContent = data.total ? `${data.total} total` : '';\n        return;\n      }\n\n      let html = '';\n      if (!append) {\n        html = '<table style=\"width: 100%; border-collapse: collapse; font-size: 0.82rem;\">';\n        html += '<tr style=\"border-bottom: 1px solid var(--border); color: var(--muted);\">';\n        html += '<th style=\"padding: 6px; text-align: left; width: 160px;\">When</th>';\n        html += '<th style=\"padding: 6px; text-align: left; width: 80px;\">Level</th>';\n        html += '<th style=\"padding: 6px; text-align: left; width: 140px;\">Context</th>';\n        html += '<th style=\"padding: 6px; text-align: left;\">Message</th>';\n        html += '<th style=\"padding: 6px; text-align: left; width: 110px;\">IP</th>';\n        html += '</tr>';\n      }\n\n      for (const log of logs) {\n        const level = (log.level || '?').toUpperCase();\n        const levelColor = level === 'ERR' ? 'var(--bad-fg)' : (level === 'WARN' ? 'var(--warn-fg, #f0c674)' : 'var(--muted)');\n        const ts = log.timestamp ? new Date(log.timestamp).toLocaleString() : '\u2014';\n        const ctx = log.context || '\u2014';\n        const msg = (log.error || '').split('\\n')[0];\n        const ip = (log.request && log.request.ip) || '';\n        html += `<tr style=\"border-bottom: 1px solid var(--border); cursor: pointer;\" class=\"error-log-row\">`;\n        html += `<td style=\"padding: 6px; color: var(--muted);\" title=\"${escapeHtml(log.timestamp || '')}\">${escapeHtml(ts)}</td>`;\n        html += `<td style=\"padding: 6px;\"><span style=\"color: ${levelColor}; font-weight: 600;\">${escapeHtml(level)}</span></td>`;\n        html += `<td style=\"padding: 6px; font-family: monospace; font-size: 0.78rem;\">${escapeHtml(ctx)}</td>`;\n        html += `<td style=\"padding: 6px;\">${escapeHtml(msg)}</td>`;\n        html += `<td style=\"padding: 6px; font-family: monospace; font-size: 0.78rem;\">${escapeHtml(ip)}</td>`;\n        html += '</tr>';\n        if (log.detail) {\n          html += `<tr class=\"error-log-detail\" style=\"display: none;\"><td colspan=\"5\" style=\"padding: 6px 6px 10px; font-size: 0.78rem; color: var(--muted);\"><pre style=\"margin: 0; white-space: pre-wrap; font-family: monospace; max-height: 320px; overflow: auto;\">${escapeHtml(log.detail)}</pre></td></tr>`;\n        }\n      }\n\n      if (!append) {\n        html += '</table>';\n        container.innerHTML = html;\n      } else {\n        const table = container.querySelector('table');\n        if (table) table.insertAdjacentHTML('beforeend', html);\n      }\n\n      currentOffset += logs.length;\n      loadMoreBtn.style.display = data.hasMore ? '' : 'none';\n      totalSpan.textContent = `${data.total} total${data.hasMore ? ' (showing ' + currentOffset + ')' : ''}`;\n\n      // Toggle detail rows on click \u2014 same pattern as audit-log.js\n      container.querySelectorAll('.error-log-row').forEach((row) => {\n        if (row.dataset.wired) return;\n        row.dataset.wired = 'true';\n        row.addEventListener('click', () => {\n          const detail = row.nextElementSibling;\n          if (detail && detail.classList.contains('error-log-detail')) {\n            detail.style.display = detail.style.display === 'none' ? '' : 'none';\n          }\n        });\n      });\n    } catch (e) {\n      if (e && e.name === 'AbortError') return;\n      container.innerHTML = `<div class=\"panel-empty\" style=\"color: var(--bad-fg);\">Failed: ${escapeHtml(e.message)}</div>`;\n      totalSpan.textContent = '';\n    }\n  }\n\n  async function clearLogs() {\n    if (!confirm('Clear the entire error log? This cannot be undone.')) return;\n    try {\n      const res = await secureFetch('/api/v1/error-logs', {\n        method: 'DELETE',\n        headers: { 'content-type': 'application/json' },\n        body: JSON.stringify({ confirm: 'CLEAR' }),\n      });\n      const data = await res.json();\n      if (data.success) {\n        // After a clear, the contexts list will be empty \u2014 re-fetch so the\n        // dropdown reflects reality. Load the now-empty page in parallel.\n        await refreshContexts();\n        loadLogs(false);\n        showNotification('\u2705 Error logs cleared', 'success', 3000);\n      } else {\n        showNotification('\u274C ' + (data.error || 'Clear failed'), 'error', 4000);\n      }\n    } catch (e) {\n      showNotification('\u274C ' + e.message, 'error', 4000);\n    }\n  }\n\n  // Debounce text-input changes so we don't refetch on every keystroke.\n  let searchDebounce;\n  function wireFilters() {\n    levelSel?.addEventListener('change', () => loadLogs(false));\n    contextSel?.addEventListener('change', () => loadLogs(false));\n    searchInput?.addEventListener('input', () => {\n      clearTimeout(searchDebounce);\n      searchDebounce = setTimeout(() => loadLogs(false), 250);\n    });\n    let dateDebounce;\n    [sinceInput, untilInput].forEach((el) => {\n      el?.addEventListener('change', () => {\n        clearTimeout(dateDebounce);\n        dateDebounce = setTimeout(() => loadLogs(false), 250);\n      });\n    });\n    refreshBtn?.addEventListener('click', () => loadLogs(false));\n    loadMoreBtn?.addEventListener('click', () => loadLogs(true));\n    clearBtn?.addEventListener('click', clearLogs);\n    wireModal(modal, closeBtn);\n  }\n\n  viewBtn?.addEventListener('click', async () => {\n    modal?.classList.add('show');\n    await refreshContexts();\n    loadLogs(false);\n  });\n  wireFilters();\n})();\n;\n// ========== CONTAINER LOG VIEWER ==========\n(function() {\n  // Inject modal HTML\n  injectModal('container-logs-modal', `<div id=\"container-logs-modal\" class=\"weather-modal\" style=\"z-index: 1001;\">\n    <div class=\"weather-modal-content\" style=\"min-width: 900px; max-width: 95vw; height: 80vh; display: flex; flex-direction: column;\">\n      <div class=\"logs-header\" style=\"display: flex; justify-content: space-between; align-items: center; padding-bottom: 12px; border-bottom: 1px solid var(--border); margin-bottom: 12px;\">\n        <div>\n          <h3 style=\"margin: 0;\">\uD83D\uDCDC Container Logs</h3>\n          <p class=\"modal-subtitle\" style=\"margin: 4px 0 0 0; font-size: 0.85rem; opacity: 0.7;\">View and stream Docker container logs</p>\n        </div>\n        <div class=\"logs-controls\" style=\"display: flex; gap: 8px; align-items: center;\">\n          <select id=\"cl-container-select\" style=\"padding: 6px 10px; border: 1px solid var(--border); border-radius: 6px; background: var(--bg); color: var(--fg); min-width: 200px;\">\n            <option value=\"\">Select a container...</option>\n          </select>\n          <input type=\"text\" id=\"cl-log-search\" placeholder=\"Search logs...\" style=\"padding: 6px 10px; border: 1px solid var(--border); border-radius: 6px; background: var(--bg); color: var(--fg); width: 150px;\" />\n          <select id=\"cl-log-tail\" style=\"padding: 6px 10px; border: 1px solid var(--border); border-radius: 6px; background: var(--bg); color: var(--fg);\">\n            <option value=\"50\">Last 50 lines</option>\n            <option value=\"100\" selected>Last 100 lines</option>\n            <option value=\"500\">Last 500 lines</option>\n            <option value=\"1000\">Last 1000 lines</option>\n            <option value=\"all\">All logs</option>\n          </select>\n          <button id=\"cl-refresh\" class=\"btn-accent-solid\" style=\"padding: 6px 14px; font-size: 0.85rem;\">\uD83D\uDD04 Refresh</button>\n          <button id=\"cl-stream\" class=\"btn-accent-solid\" style=\"padding: 6px 14px; font-size: 0.85rem;\">\u25B6 Stream</button>\n          <button id=\"cl-download\" style=\"padding: 6px 14px; font-size: 0.85rem;\">\uD83D\uDCBE Download</button>\n          <button id=\"cl-clear-search\" style=\"padding: 6px 10px; font-size: 0.85rem;\" title=\"Clear search\">\u2715</button>\n          <button id=\"cl-close\" class=\"close-btn\" style=\"padding: 6px 10px;\">\u2715</button>\n        </div>\n      </div>\n      \n      <div id=\"cl-container-info\" style=\"display: flex; gap: 16px; margin-bottom: 12px; padding: 8px 12px; background: var(--bg-secondary, var(--bg)); border-radius: 6px; font-size: 0.82rem;\">\n        <span><strong>Image:</strong> <span id=\"cl-image\">-</span></span>\n        <span><strong>Status:</strong> <span id=\"cl-status\">-</span></span>\n        <span><strong>Created:</strong> <span id=\"cl-created\">-</span></span>\n      </div>\n      \n      <div id=\"cl-log-content\" class=\"logs-content scroll-container\" style=\"flex: 1; min-height: 0; background: #1a1a1a; border-radius: 6px; padding: 12px; font-family: 'Monaco', 'Menlo', 'Ubuntu Mono', monospace; font-size: 0.78rem; overflow: auto;\">\n        <div class=\"logs-loading\" style=\"color: var(--muted); text-align: center; padding: 40px;\">Select a container to view logs</div>\n      </div>\n      \n      <div id=\"cl-stream-status\" style=\"display: none; padding: 8px 12px; background: var(--ok-bg, #1a3a1a); color: var(--ok-fg, #4ade80); border-radius: 6px; margin-top: 8px; font-size: 0.82rem;\">\n        <span id=\"cl-stream-indicator\">\uD83D\uDD34</span> <span id=\"cl-stream-text\">Disconnected</span>\n      </div>\n      \n      <div class=\"weather-modal-buttons modal-footer-bar\" style=\"margin-top: 12px; padding-top: 12px; border-top: 1px solid var(--border);\">\n        <div style=\"display: flex; gap: 8px; font-size: 0.78rem; color: var(--muted);\">\n          <span id=\"cl-line-count\">0 lines</span>\n          <span>|</span>\n          <span id=\"cl-filter-count\">0 filtered</span>\n        </div>\n        <button id=\"cl-close-btn\" class=\"btn-secondary\">Close</button>\n      </div>\n    </div>\n  </div>`);\n\n  const modal = document.getElementById('container-logs-modal');\n  const containerSelect = document.getElementById('cl-container-select');\n  const logContent = document.getElementById('cl-log-content');\n  const logSearch = document.getElementById('cl-log-search');\n  const logTail = document.getElementById('cl-log-tail');\n  const refreshBtn = document.getElementById('cl-refresh');\n  const streamBtn = document.getElementById('cl-stream');\n  const downloadBtn = document.getElementById('cl-download');\n  const clearSearchBtn = document.getElementById('cl-clear-search');\n  const closeBtn = document.getElementById('cl-close');\n  const closeBtn2 = document.getElementById('cl-close-btn');\n  const streamStatus = document.getElementById('cl-stream-status');\n  const streamIndicator = document.getElementById('cl-stream-indicator');\n  const streamText = document.getElementById('cl-stream-text');\n  const lineCount = document.getElementById('cl-line-count');\n  const filterCount = document.getElementById('cl-filter-count');\n  \n  // Container info elements\n  const imageEl = document.getElementById('cl-image');\n  const statusEl = document.getElementById('cl-status');\n  const createdEl = document.getElementById('cl-created');\n\n  let currentContainerId = null;\n  let currentLogs = [];\n  let filteredLogs = [];\n  let eventSource = null;\n  let isStreaming = false;\n  let searchTimeout = null;\n\n  // Format date\n  function formatDate(dateStr) {\n    if (!dateStr) return '-';\n    const d = new Date(dateStr);\n    if (isNaN(d.getTime())) return dateStr;\n    return d.toLocaleString();\n  }\n\n  // Escape HTML\n  function escapeHtml(str) {\n    if (!str) return '';\n    const div = document.createElement('div');\n    div.textContent = str;\n    return div.innerHTML;\n  }\n\n  // Format log entry for display\n  function formatLogEntry(log, index) {\n    const streamClass = log.stream === 'stderr' ? 'log-stderr' : 'log-stdout';\n    const streamIcon = log.stream === 'stderr' ? '\u26A0\uFE0F' : '\uD83D\uDCE4';\n    return `\n      <div class=\"log-entry ${streamClass}\" data-index=\"${index}\" style=\"padding: 4px 8px; border-bottom: 1px solid #333; display: flex; gap: 8px;\">\n        <span class=\"log-line-num\" style=\"color: #666; min-width: 40px; text-align: right; user-select: none;\">${index + 1}</span>\n        <span class=\"log-stream-icon\" style=\"color: ${log.stream === 'stderr' ? '#f59e0b' : '#22c55e'};\">${streamIcon}</span>\n        <span class=\"log-text\" style=\"flex: 1; white-space: pre-wrap; word-break: break-all; color: #e5e5e5;\">${escapeHtml(log.text)}</span>\n      </div>\n    `;\n  }\n\n  // Render logs to the content area\n  function renderLogs(logs, searchTerm = '') {\n    if (!logs || logs.length === 0) {\n      logContent.innerHTML = '<div class=\"logs-loading\" style=\"color: var(--muted); text-align: center; padding: 40px;\">No logs available</div>';\n      lineCount.textContent = '0 lines';\n      filterCount.textContent = '0 filtered';\n      return;\n    }\n\n    currentLogs = logs;\n    filteredLogs = searchTerm ? logs.filter(log => \n      log.text && log.text.toLowerCase().includes(searchTerm.toLowerCase())\n    ) : logs;\n\n    lineCount.textContent = `${logs.length} lines`;\n    filterCount.textContent = searchTerm ? `${filteredLogs.length} of ${logs.length} shown` : `${logs.length} shown`;\n\n    if (filteredLogs.length === 0) {\n      logContent.innerHTML = `<div class=\"logs-loading\" style=\"color: var(--muted); text-align: center; padding: 40px;\">No logs match \"${escapeHtml(searchTerm)}\"</div>`;\n      return;\n    }\n\n    logContent.innerHTML = filteredLogs.map((log, i) => formatLogEntry(log, i)).join('');\n    \n    // Scroll to bottom\n    logContent.scrollTop = logContent.scrollHeight;\n  }\n\n  // Load container list\n  async function loadContainers() {\n    try {\n      const data = await getJSON('/api/v1/logs/containers');\n      const containers = data.containers || [];\n      \n      // Store current selection\n      const currentVal = containerSelect.value;\n      \n      containerSelect.innerHTML = '<option value=\"\">Select a container...</option>';\n      \n      containers.forEach(c => {\n        const option = document.createElement('option');\n        option.value = c.id;\n        option.textContent = `${c.name} (${c.image.split(':')[0]}) - ${c.status}`;\n        option.dataset.name = c.name;\n        option.dataset.image = c.image;\n        option.dataset.status = c.status;\n        option.dataset.created = c.created;\n        containerSelect.appendChild(option);\n      });\n      \n      // Restore selection if still valid\n      if (currentVal && containerSelect.querySelector(`option[value=\"${currentVal}\"]`)) {\n        containerSelect.value = currentVal;\n        loadContainerInfo(currentVal);\n      }\n    } catch (err) {\n      console.error('Failed to load containers:', err);\n    }\n  }\n\n  // Load container info\n  function loadContainerInfo(containerId) {\n    const option = containerSelect.querySelector(`option[value=\"${containerId}\"]`);\n    if (option) {\n      imageEl.textContent = option.dataset.image || '-';\n      statusEl.textContent = option.dataset.status || '-';\n      statusEl.style.color = option.dataset.status === 'running' ? 'var(--ok-fg, #4ade80)' : 'var(--bad-fg, #ef4444)';\n      createdEl.textContent = formatDate(option.dataset.created);\n    }\n  }\n\n  // Load logs for selected container\n  async function loadLogs() {\n    const containerId = containerSelect.value;\n    if (!containerId) {\n      logContent.innerHTML = '<div class=\"logs-loading\" style=\"color: var(--muted); text-align: center; padding: 40px;\">Select a container to view logs</div>';\n      return;\n    }\n\n    // Stop any existing stream\n    stopStream();\n\n    currentContainerId = containerId;\n    loadContainerInfo(containerId);\n\n    const tail = logTail.value;\n    const searchTerm = logSearch.value.trim();\n\n    logContent.innerHTML = '<div class=\"logs-loading\" style=\"color: var(--muted); text-align: center; padding: 40px;\">Loading logs...</div>';\n\n    try {\n      const url = `/api/v1/logs/container/${containerId}${tail !== 'all' ? `?tail=${tail}` : ''}`;\n      const data = await getJSON(url);\n\n      if (data.logs && data.logs.length > 0) {\n        renderLogs(data.logs, searchTerm);\n      } else {\n        logContent.innerHTML = '<div class=\"logs-loading\" style=\"color: var(--muted); text-align: center; padding: 40px;\">No logs found for this container</div>';\n        lineCount.textContent = '0 lines';\n        filterCount.textContent = '0 filtered';\n      }\n    } catch (err) {\n      logContent.innerHTML = `<div class=\"logs-loading\" style=\"color: var(--bad-fg, #ef4444); text-align: center; padding: 40px;\">Error loading logs: ${escapeHtml(err.message)}</div>`;\n    }\n  }\n\n  // Start streaming logs\n  function startStream() {\n    const containerId = containerSelect.value;\n    if (!containerId) return;\n\n    // Stop any existing stream\n    stopStream();\n\n    isStreaming = true;\n    streamBtn.textContent = '\u23F9 Stop';\n    streamStatus.style.display = 'flex';\n    streamIndicator.textContent = '\uD83D\uDFE2';\n    streamText.textContent = 'Connecting...';\n\n    const url = `/api/v1/logs/stream/${containerId}`;\n    eventSource = new EventSource(url);\n\n    eventSource.onopen = () => {\n      streamIndicator.textContent = '\uD83D\uDFE2';\n      streamText.textContent = 'Connected - streaming logs';\n    };\n\n    eventSource.onmessage = (event) => {\n      try {\n        const log = JSON.parse(event.data);\n        \n        if (log.error) {\n          streamIndicator.textContent = '\uD83D\uDD34';\n          streamText.textContent = `Error: ${log.error}`;\n          return;\n        }\n\n        // Add to current logs\n        currentLogs.push(log);\n        filteredLogs.push(log);\n        \n        // Update counts\n        lineCount.textContent = `${currentLogs.length} lines`;\n        filterCount.textContent = `${filteredLogs.length} shown`;\n        \n        // Append new log entry\n        const searchTerm = logSearch.value.trim();\n        if (!searchTerm || (log.text && log.text.toLowerCase().includes(searchTerm.toLowerCase()))) {\n          const entry = document.createElement('div');\n          entry.innerHTML = formatLogEntry(log, filteredLogs.length - 1);\n          const entryDiv = entry.firstElementChild;\n          entryDiv.style.background = '#1a3a1a';\n          logContent.appendChild(entryDiv);\n          \n          // Auto-scroll to bottom\n          logContent.scrollTop = logContent.scrollHeight;\n        }\n      } catch (e) {\n        console.error('Error parsing log:', e);\n      }\n    };\n\n    eventSource.onerror = () => {\n      streamIndicator.textContent = '\uD83D\uDD34';\n      streamText.textContent = 'Disconnected';\n      isStreaming = false;\n      streamBtn.textContent = '\u25B6 Stream';\n    };\n\n    // Store the EventSource for cleanup\n    modal._eventSource = eventSource;\n  }\n\n  // Stop streaming logs\n  function stopStream() {\n    if (eventSource) {\n      eventSource.close();\n      eventSource = null;\n    }\n    if (modal._eventSource) {\n      modal._eventSource.close();\n      modal._eventSource = null;\n    }\n    isStreaming = false;\n    streamBtn.textContent = '\u25B6 Stream';\n    streamStatus.style.display = 'none';\n  }\n\n  // Download logs as file\n  function downloadLogs() {\n    if (!currentLogs || currentLogs.length === 0) {\n      showNotification('No logs to download', 'error');\n      return;\n    }\n\n    const containerName = containerSelect.querySelector(`option[value=\"${currentContainerId}\"]`)?.dataset.name || currentContainerId;\n    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');\n    const filename = `${containerName}-logs-${timestamp}.txt`;\n\n    const content = currentLogs.map(log => {\n      const timestamp = log.timestamp || '';\n      const stream = log.stream === 'stderr' ? '[ERR]' : '[OUT]';\n      return `${timestamp ? timestamp + ' ' : ''}${stream} ${log.text}`;\n    }).join('\\n');\n\n    const blob = new Blob([content], { type: 'text/plain' });\n    const url = URL.createObjectURL(blob);\n    const a = document.createElement('a');\n    a.href = url;\n    a.download = filename;\n    document.body.appendChild(a);\n    a.click();\n    document.body.removeChild(a);\n    URL.revokeObjectURL(url);\n\n    showNotification(`Downloaded ${currentLogs.length} log lines`, 'success');\n  }\n\n  // Event listeners\n  containerSelect?.addEventListener('change', () => {\n    loadLogs();\n  });\n\n  logTail?.addEventListener('change', () => {\n    loadLogs();\n  });\n\n  refreshBtn?.addEventListener('click', () => {\n    loadLogs();\n  });\n\n  streamBtn?.addEventListener('click', () => {\n    if (isStreaming) {\n      stopStream();\n    } else {\n      startStream();\n    }\n  });\n\n  downloadBtn?.addEventListener('click', () => {\n    downloadLogs();\n  });\n\n  clearSearchBtn?.addEventListener('click', () => {\n    logSearch.value = '';\n    renderLogs(currentLogs, '');\n  });\n\n  logSearch?.addEventListener('input', () => {\n    // Debounce search\n    clearTimeout(searchTimeout);\n    searchTimeout = setTimeout(() => {\n      renderLogs(currentLogs, logSearch.value.trim());\n    }, 300);\n  });\n\n  logSearch?.addEventListener('keydown', (e) => {\n    if (e.key === 'Escape') {\n      logSearch.value = '';\n      renderLogs(currentLogs, '');\n    }\n  });\n\n  // Open modal\n  const openBtn = document.getElementById('view-container-logs');\n  openBtn?.addEventListener('click', () => {\n    modal.classList.add('show');\n    loadContainers();\n  });\n\n  // Close modal handlers\n  function closeModal() {\n    stopStream();\n    modal.classList.remove('show');\n  }\n\n  closeBtn?.addEventListener('click', closeModal);\n  closeBtn2?.addEventListener('click', closeModal);\n\n  // Close on escape key\n  document.addEventListener('keydown', (e) => {\n    if (e.key === 'Escape' && modal.classList.contains('show')) {\n      closeModal();\n    }\n  });\n\n  // Wire backdrop click to closeModal so the log stream stops too.\n  // (Can't use wireModal here \u2014 it only does modal.classList.remove('show')\n  // on backdrop click, which would leak the SSE/stream connection.)\n  modal.addEventListener('click', (e) => { if (e.target === modal) closeModal(); });\n\n  // Expose for use by service card buttons (grid.js calls openContainerLogsModal)\n  window.openContainerLogsModal = function(containerId, containerName) {\n    modal.classList.add('show');\n    loadContainers().then(() => {\n      // Try to find and select the container\n      const option = Array.from(containerSelect.options).find(opt => \n        opt.value === containerId || opt.dataset.name === containerName\n      );\n      if (option) {\n        containerSelect.value = option.value;\n        loadContainerInfo(option.value);\n        loadLogs();\n      } else if (containerId) {\n        // If container not found in list but we have an ID, try loading directly\n        currentContainerId = containerId;\n        imageEl.textContent = containerName || containerId;\n        statusEl.textContent = '-';\n        createdEl.textContent = '-';\n        loadLogs();\n      } else {\n        // No container ID, just show modal with container list\n        logContent.innerHTML = '<div class=\"logs-loading\" style=\"color: var(--muted); text-align: center; padding: 40px;\">Select a container to view logs</div>';\n      }\n    });\n  };\n})();\n;\n// ========== DC-055: HOST JOURNALD LOG VIEWER ==========\n// Streams host service logs (caddy, dashcaddy-api, docker, ssh, \u2026) via the\n// journalctl bind-mount added in start.sh. Server-Sent Events for live\n// tailing; bounded non-streaming read for historical views.\n(function() {\n  'use strict';\n\n  // Allow-list mirrors the backend's ALLOWED_UNITS so the dropdown stays\n  // honest when the bind-mount isn't available. The server is still the\n  // source of truth \u2014 anything not in its allow-list returns 400.\n  const UNIT_PRESETS = [\n    { unit: 'caddy',          label: 'Caddy (reverse proxy)' },\n    { unit: 'dashcaddy-api',  label: 'DashCaddy API (host systemd unit, not this container)' },\n    { unit: 'docker',         label: 'Docker daemon' },\n    { unit: 'ssh',            label: 'SSH server' },\n    { unit: 'systemd-journald', label: 'systemd-journald' },\n    { unit: 'tailscaled',     label: 'Tailscale' },\n    { unit: 'networkd-dispatcher', label: 'Networkd dispatcher' },\n  ];\n\n  injectModal('journald-modal', `\n    <div id=\"journald-modal\" class=\"weather-modal\" style=\"z-index: 1002;\">\n      <div class=\"weather-modal-content\" style=\"min-width: 900px; max-width: 95vw; height: 80vh; display: flex; flex-direction: column;\">\n        <div class=\"logs-header\" style=\"display: flex; justify-content: space-between; align-items: center; padding-bottom: 12px; border-bottom: 1px solid var(--border); margin-bottom: 12px;\">\n          <div>\n            <h3 style=\"margin: 0;\">\uD83D\uDEF0\uFE0F Host Logs (journald)</h3>\n            <p class=\"modal-subtitle\" style=\"margin: 4px 0 0 0; font-size: 0.85rem; opacity: 0.7;\">\n              Stream host service logs from <code>journalctl</code> (read-only mount). Docker container logs are still in the <em>Container Logs</em> modal.\n            </p>\n          </div>\n          <div class=\"logs-controls\" style=\"display: flex; gap: 8px; align-items: center; flex-wrap: wrap; justify-content: flex-end;\">\n            <select id=\"jd-unit-select\" style=\"padding: 6px 10px; border: 1px solid var(--border); border-radius: 6px; background: var(--bg); color: var(--fg); min-width: 220px;\"></select>\n            <input type=\"text\" id=\"jd-search\" placeholder=\"Search logs...\" style=\"padding: 6px 10px; border: 1px solid var(--border); border-radius: 6px; background: var(--bg); color: var(--fg); width: 160px;\" />\n            <input type=\"number\" id=\"jd-tail\" min=\"1\" max=\"5000\" value=\"200\" title=\"Lines to load (historical view)\" style=\"padding: 6px 10px; border: 1px solid var(--border); border-radius: 6px; background: var(--bg); color: var(--fg); width: 90px;\" />\n            <button id=\"jd-refresh\" class=\"btn-accent-solid\" style=\"padding: 6px 14px; font-size: 0.85rem;\">\uD83D\uDD04 Load tail</button>\n            <button id=\"jd-stream\" class=\"btn-accent-solid\" style=\"padding: 6px 14px; font-size: 0.85rem;\">\u25B6 Stream</button>\n            <button id=\"jd-clear-search\" style=\"padding: 6px 10px; font-size: 0.85rem;\" title=\"Clear search\">\u2715</button>\n            <button id=\"jd-close\" class=\"close-btn\" style=\"padding: 6px 10px;\">\u2715</button>\n          </div>\n        </div>\n\n        <div id=\"jd-meta\" style=\"display: flex; gap: 16px; margin-bottom: 12px; padding: 8px 12px; background: var(--bg-secondary, var(--bg)); border-radius: 6px; font-size: 0.82rem; flex-wrap: wrap;\">\n          <span><strong>Source:</strong> <span id=\"jd-source\">journald</span></span>\n          <span><strong>Unit:</strong> <span id=\"jd-unit-display\">-</span></span>\n          <span><strong>Stream:</strong> <span id=\"jd-stream-state\">disconnected</span></span>\n        </div>\n\n        <div id=\"jd-content\" class=\"logs-content scroll-container\" style=\"flex: 1; min-height: 0; background: #1a1a1a; border-radius: 6px; padding: 12px; font-family: 'Monaco', 'Menlo', 'Ubuntu Mono', monospace; font-size: 0.78rem; overflow: auto;\">\n          <div class=\"logs-loading\" style=\"color: var(--muted); text-align: center; padding: 40px;\">Select a unit and click <em>Load tail</em> or <em>Stream</em>.</div>\n        </div>\n\n        <div class=\"weather-modal-buttons modal-footer-bar\" style=\"margin-top: 12px; padding-top: 12px; border-top: 1px solid var(--border);\">\n          <div style=\"display: flex; gap: 8px; font-size: 0.78rem; color: var(--muted);\">\n            <span id=\"jd-line-count\">0 lines</span>\n            <span>|</span>\n            <span id=\"jd-filter-count\">0 shown</span>\n            <span>|</span>\n            <span id=\"jd-overflow\" style=\"display: none; color: var(--warn-fg, #fbbf24);\">\u26A0 stream overflow \u2014 re-load with narrower window</span>\n          </div>\n          <button id=\"jd-close-btn\" class=\"btn-secondary\">Close</button>\n        </div>\n      </div>\n    </div>\n  `);\n\n  const modal        = document.getElementById('journald-modal');\n  const unitSelect   = document.getElementById('jd-unit-select');\n  const searchInput  = document.getElementById('jd-search');\n  const tailInput    = document.getElementById('jd-tail');\n  const refreshBtn   = document.getElementById('jd-refresh');\n  const streamBtn    = document.getElementById('jd-stream');\n  const clearSearch  = document.getElementById('jd-clear-search');\n  const closeBtn     = document.getElementById('jd-close');\n  const closeBtn2    = document.getElementById('jd-close-btn');\n  const content      = document.getElementById('jd-content');\n  const lineCount    = document.getElementById('jd-line-count');\n  const filterCount  = document.getElementById('jd-filter-count');\n  const overflowHint = document.getElementById('jd-overflow');\n  const unitDisplay  = document.getElementById('jd-unit-display');\n  const streamState  = document.getElementById('jd-stream-state');\n\n  let available = false;     // /var/log/journal mounted?\n  let lines = [];            // current buffer (array of {timestamp, unit, text})\n  let streaming = false;\n  let eventSource = null;\n  let searchTimer = null;\n\n  function escapeHtml(s) {\n    // Local re-declaration so we don't depend on a global; same semantics\n    // as the helper used by container-logs.js and error-logs.js.\n    const div = document.createElement('div');\n    div.textContent = String(s);\n    return div.innerHTML;\n  }\n\n  function setAvailable(isAvailable) {\n    available = isAvailable;\n    unitSelect.innerHTML = '';\n    UNIT_PRESETS.forEach(p => {\n      const opt = document.createElement('option');\n      opt.value = p.unit;\n      opt.textContent = p.label + ' (' + p.unit + ')';\n      unitSelect.appendChild(opt);\n    });\n    unitSelect.disabled = !isAvailable;\n    if (!isAvailable) {\n      content.innerHTML = '<div class=\"logs-loading\" style=\"color: var(--muted); text-align: center; padding: 40px;\">journald bind-mount not available in this container.<br/><small>Requires <code>/var/log/journal</code> + <code>/usr/bin/journalctl</code> mounted (start.sh).</small></div>';\n      refreshBtn.disabled = true;\n      streamBtn.disabled = true;\n    } else {\n      refreshBtn.disabled = false;\n      streamBtn.disabled = false;\n    }\n  }\n\n  async function probeAvailable() {\n    try {\n      const resp = await fetch('/api/v1/logs/journal/units');\n      if (!resp.ok) { setAvailable(false); return; }\n      const data = await resp.json();\n      setAvailable(!!data.available);\n    } catch (e) {\n      setAvailable(false);\n    }\n  }\n\n  function renderLines() {\n    const term = (searchInput.value || '').trim().toLowerCase();\n    const filtered = term ? lines.filter(l => (l.textContent || '').toLowerCase().includes(term)) : lines;\n    if (filtered.length === 0) {\n      content.innerHTML = '<div class=\"logs-loading\" style=\"color: var(--muted); text-align: center; padding: 40px;\">No entries' + (term ? ` matching &quot;${escapeHtml(term)}&quot;` : '') + '</div>';\n    } else {\n      const html = filtered.map(line => {\n        const ts = line.timestamp ? escapeHtml(line.timestamp) : '\u2014';\n        const t = escapeHtml(line.textContent);\n        return `<div class=\"jd-line\" style=\"padding: 1px 0; line-height: 1.4; color: #d4d4d4;\"><span style=\"color: var(--muted); margin-right: 8px;\">${ts}</span>${t}</div>`;\n      }).join('');\n      content.innerHTML = html;\n      // Auto-scroll only if user is already at the bottom (don't fight them).\n      const nearBottom = content.scrollHeight - content.scrollTop - content.clientHeight < 80;\n      if (nearBottom) content.scrollTop = content.scrollHeight;\n    }\n    lineCount.textContent = `${lines.length} entries`;\n    filterCount.textContent = term ? `${filtered.length} of ${lines.length} shown` : `${lines.length} shown`;\n  }\n\n  async function loadTail() {\n    if (!available) return;\n    stopStream();\n    const unit = unitSelect.value;\n    if (!unit) return;\n    const tail = Math.max(1, Math.min(5000, Number(tailInput.value) || 200));\n    const term = (searchInput.value || '').trim();\n    content.innerHTML = '<div class=\"logs-loading\" style=\"color: var(--muted); text-align: center; padding: 40px;\">Loading\u2026</div>';\n    try {\n      const url = new URL('/api/v1/logs/journal', window.location.origin);\n      url.searchParams.set('unit', unit);\n      url.searchParams.set('tail', String(tail));\n      if (term) url.searchParams.set('search', term);\n      const resp = await fetch(url.toString());\n      const data = await resp.json();\n      if (!resp.ok || !data.success) {\n        content.innerHTML = '<div class=\"logs-loading\" style=\"color: var(--bad-fg, #ef4444); text-align: center; padding: 40px;\">Failed: ' + escapeHtml((data && data.error) || ('HTTP ' + resp.status)) + '</div>';\n        return;\n      }\n      unitDisplay.textContent = unit;\n      lines = (data.entries || []).map(e => ({\n        timestamp: e.timestamp,\n        unit: e.unit,\n        textContent: e.text || '',\n      }));\n      overflowHint.style.display = 'none';\n      renderLines();\n    } catch (e) {\n      content.innerHTML = '<div class=\"logs-loading\" style=\"color: var(--bad-fg, #ef4444); text-align: center; padding: 40px;\">Error: ' + escapeHtml(e.message) + '</div>';\n    }\n  }\n\n  function startStream() {\n    if (!available) return;\n    stopStream();\n    const unit = unitSelect.value;\n    if (!unit) return;\n    const term = (searchInput.value || '').trim();\n    unitDisplay.textContent = unit;\n    streamBtn.textContent = '\u23F8 Stop';\n    streamBtn.classList.add('streaming');\n    streamState.textContent = 'streaming';\n    streamState.style.color = 'var(--ok-fg, #4ade80)';\n    lines = [];\n    renderLines();\n    overflowHint.style.display = 'none';\n    const url = new URL('/api/v1/logs/journal/stream', window.location.origin);\n    url.searchParams.set('unit', unit);\n    if (term) url.searchParams.set('search', term);\n    eventSource = new EventSource(url.toString());\n    eventSource.onmessage = (ev) => {\n      try {\n        const entry = JSON.parse(ev.data);\n        if (entry.error) {\n          // Overflow / validation / bind-mount errors\n          if (/stream (exceeded|line cap)/.test(entry.error)) {\n            overflowHint.style.display = '';\n            stopStream();\n          }\n          content.innerHTML += '<div class=\"jd-line\" style=\"color: var(--bad-fg, #ef4444); padding: 4px 0;\">\u26A0 ' + escapeHtml(entry.error) + '</div>';\n          content.scrollTop = content.scrollHeight;\n          return;\n        }\n        lines.push({\n          timestamp: entry.timestamp,\n          unit: entry.unit || unit,\n          textContent: entry.text || '',\n        });\n        // Hard cap to keep memory bounded if operator streams forever.\n        if (lines.length > 5000) {\n          lines = lines.slice(lines.length - 5000);\n          overflowHint.style.display = '';\n        }\n        renderLines();\n      } catch (_) {\n        // Ignore malformed events; the server is authoritative.\n      }\n    };\n    eventSource.onerror = () => {\n      // EventSource auto-reconnects; mark transient if we were expecting\n      // more, otherwise we closed it deliberately.\n      if (!streaming) return;\n    };\n    streaming = true;\n  }\n\n  function stopStream() {\n    streaming = false;\n    if (eventSource) {\n      try { eventSource.close(); } catch (_) { /* ignore */ }\n      eventSource = null;\n    }\n    streamBtn.textContent = '\u25B6 Stream';\n    streamBtn.classList.remove('streaming');\n    streamState.textContent = 'disconnected';\n    streamState.style.color = 'var(--muted)';\n  }\n\n  function close() {\n    stopStream();\n    modal.classList.remove('show');\n  }\n\n  // Wire events\n  refreshBtn.addEventListener('click', loadTail);\n  streamBtn.addEventListener('click', () => streaming ? stopStream() : startStream());\n  clearSearch.addEventListener('click', () => { searchInput.value = ''; renderLines(); });\n  searchInput.addEventListener('input', () => {\n    clearTimeout(searchTimer);\n    searchTimer = setTimeout(renderLines, 200);\n  });\n  searchInput.addEventListener('keydown', (e) => {\n    if (e.key === 'Escape') { searchInput.value = ''; renderLines(); }\n  });\n  closeBtn.addEventListener('click', close);\n  closeBtn2.addEventListener('click', close);\n  modal.addEventListener('click', (e) => { if (e.target === modal) close(); });\n  document.addEventListener('keydown', (e) => {\n    if (e.key === 'Escape' && modal.classList.contains('show')) close();\n  });\n  // Reload tail automatically when the unit dropdown changes (if we have\n  // data already \u2014 saves a click).\n  unitSelect.addEventListener('change', () => {\n    if (lines.length > 0) loadTail();\n  });\n\n  // Hook into the existing \"Container Logs\" modal button so operators get a\n  // separate entry point; mirror the openContainerLogsModal pattern.\n  function openJournaldModal() {\n    modal.classList.add('show');\n    probeAvailable();\n  }\n  window.openJournaldModal = openJournaldModal;\n\n  document.getElementById('view-journald-logs')?.addEventListener('click', openJournaldModal);\n})();;\n// ========== CONTAINER SNAPSHOT / CHECKPOINT ==========\n(function() {\n  // Inject modal HTML\n  injectModal('snapshot-modal', `<div id=\"snapshot-modal\" class=\"weather-modal\">\n    <div class=\"weather-modal-content\" style=\"min-width: 700px; max-width: 850px;\">\n      <h3>\uD83D\uDCBE Container Snapshots</h3>\n      <p class=\"modal-subtitle\">\n        Create and manage Docker container checkpoints for instant state recovery.\n      </p>\n\n      <div id=\"snapshot-container-select-wrapper\" style=\"margin-bottom: 16px;\">\n        <label style=\"font-size: 0.85rem; color: var(--muted);\">Select Container:</label>\n        <select id=\"snapshot-container-select\" style=\"width: 100%; padding: 8px 12px; margin-top: 4px; background: var(--bg); border: 1px solid var(--border); border-radius: 6px; color: var(--fg); font-size: 0.9rem;\">\n          <option value=\"\">-- Select a container --</option>\n        </select>\n      </div>\n\n      <div id=\"snapshot-details\" style=\"display: none; margin-bottom: 16px; padding: 12px; border: 1px solid var(--border); border-radius: 8px; background: var(--card-hover);\">\n        <div style=\"display: grid; grid-template-columns: 1fr 1fr; gap: 8px; font-size: 0.85rem;\">\n          <div><span style=\"color: var(--muted);\">Image:</span> <span id=\"snapshot-image\"></span></div>\n          <div><span style=\"color: var(--muted);\">Status:</span> <span id=\"snapshot-status\"></span></div>\n          <div><span style=\"color: var(--muted);\">Created:</span> <span id=\"snapshot-created\"></span></div>\n          <div><span style=\"color: var(--muted);\">Container ID:</span> <span id=\"snapshot-id\" style=\"font-family: monospace;\"></span></div>\n        </div>\n      </div>\n\n      <div class=\"panel-tabs\" style=\"margin-bottom: 12px;\">\n        <button class=\"panel-tab active\" data-panel=\"snapshot-create\">Create Snapshot</button>\n        <button class=\"panel-tab\" data-panel=\"snapshot-list\">Manage Snapshots</button>\n      </div>\n\n      <div id=\"snapshot-create\" class=\"panel-section active\">\n        <div style=\"margin-bottom: 12px;\">\n          <label style=\"font-size: 0.85rem; color: var(--muted);\">Snapshot Name:</label>\n          <input type=\"text\" id=\"snapshot-name\" placeholder=\"e.g., before-update-2024\" \n            style=\"width: 100%; padding: 8px 12px; margin-top: 4px; background: var(--bg); border: 1px solid var(--border); border-radius: 6px; color: var(--fg); font-size: 0.9rem; box-sizing: border-box;\" />\n        </div>\n        <div style=\"margin-bottom: 12px;\">\n          <label class=\"checkbox-label\" style=\"font-size: 0.85rem;\">\n            <input type=\"checkbox\" id=\"snapshot-leave-running\" checked />\n            Leave container running after checkpoint (resume without restart)\n          </label>\n        </div>\n        <button id=\"snapshot-create-btn\" class=\"btn-accent-solid\" style=\"width: 100%;\">\uD83D\uDCBE Create Snapshot</button>\n        <div id=\"snapshot-create-status\" style=\"margin-top: 12px; text-align: center; font-size: 0.85rem;\"></div>\n      </div>\n\n      <div id=\"snapshot-list\" class=\"panel-section\" style=\"display: none;\">\n        <div id=\"snapshot-list-container\" class=\"scroll-container\" style=\"max-height: 300px;\">\n          <div class=\"panel-empty\"><span class=\"empty-icon\">\uD83D\uDCBE</span>Select a container to view its snapshots</div>\n        </div>\n      </div>\n\n      <div class=\"weather-modal-buttons modal-footer-bar\">\n        <button id=\"snapshot-close\">Close</button>\n      </div>\n    </div>\n  </div>`);\n\n  const modal = document.getElementById('snapshot-modal');\n  const openBtn = document.getElementById('snapshot-btn');\n  const closeBtn = document.getElementById('snapshot-close');\n  const containerSelect = document.getElementById('snapshot-container-select');\n  const detailsDiv = document.getElementById('snapshot-details');\n  const createBtn = document.getElementById('snapshot-create-btn');\n  const createStatus = document.getElementById('snapshot-create-status');\n\n  let currentContainerId = null;\n\n  async function loadContainers() {\n    try {\n      const res = await fetch('/api/v1/containers');\n      const data = await res.json();\n      if (!data.success || !data.containers) return;\n      \n      containerSelect.innerHTML = '<option value=\"\">-- Select a container --</option>';\n      for (const c of data.containers) {\n        const opt = document.createElement('option');\n        opt.value = c.id;\n        opt.textContent = `${c.name || c.id} (${c.image || 'unknown'})`;\n        opt.dataset.name = c.name;\n        opt.dataset.image = c.image;\n        opt.dataset.status = c.status;\n        opt.dataset.created = c.created;\n        containerSelect.appendChild(opt);\n      }\n    } catch (e) {\n      console.error('Failed to load containers:', e);\n    }\n  }\n\n  function showContainerDetails(opt) {\n    if (!opt || !opt.value) {\n      detailsDiv.style.display = 'none';\n      currentContainerId = null;\n      return;\n    }\n    currentContainerId = opt.value;\n    document.getElementById('snapshot-image').textContent = opt.dataset.image || '-';\n    document.getElementById('snapshot-status').textContent = opt.dataset.status || '-';\n    document.getElementById('snapshot-created').textContent = opt.dataset.created ? new Date(opt.dataset.created * 1000).toLocaleString() : '-';\n    document.getElementById('snapshot-id').textContent = opt.value.substring(0, 12);\n    detailsDiv.style.display = '';\n  }\n\n  async function createSnapshot() {\n    if (!currentContainerId) {\n      createStatus.textContent = 'Please select a container first';\n      createStatus.style.color = 'var(--bad-fg)';\n      return;\n    }\n    const name = document.getElementById('snapshot-name').value.trim();\n    if (!name) {\n      createStatus.textContent = 'Please enter a snapshot name';\n      createStatus.style.color = 'var(--bad-fg)';\n      return;\n    }\n    const leaveRunning = document.getElementById('snapshot-leave-running').checked;\n    \n    createBtn.disabled = true;\n    createBtn.textContent = 'Creating...';\n    createStatus.textContent = '';\n    \n    try {\n      const res = await fetch(`/api/v1/containers/${encodeURIComponent(currentContainerId)}/checkpoint`, {\n        method: 'POST',\n        headers: { 'Content-Type': 'application/json' },\n        body: JSON.stringify({ name, leaveRunning })\n      });\n      const data = await res.json();\n      if (data.success) {\n        createStatus.textContent = `\u2713 Snapshot \"${name}\" created successfully`;\n        createStatus.style.color = 'var(--ok-fg)';\n        document.getElementById('snapshot-name').value = '';\n      } else {\n        createStatus.textContent = `\u2717 Failed: ${data.error || 'Unknown error'}`;\n        createStatus.style.color = 'var(--bad-fg)';\n      }\n    } catch (e) {\n      createStatus.textContent = `\u2717 Error: ${e.message}`;\n      createStatus.style.color = 'var(--bad-fg)';\n    } finally {\n      createBtn.disabled = false;\n      createBtn.textContent = '\uD83D\uDCBE Create Snapshot';\n    }\n  }\n\n  function openModal() {\n    modal.classList.add('show');\n    loadContainers();\n  }\n\n  function closeModal() {\n    modal.classList.remove('show');\n    detailsDiv.style.display = 'none';\n    currentContainerId = null;\n    containerSelect.selectedIndex = 0;\n  }\n\n  openBtn?.addEventListener('click', openModal);\n  closeBtn?.addEventListener('click', closeModal);\n  wireModal(modal, closeBtn);\n  \n  containerSelect?.addEventListener('change', (e) => {\n    const opt = containerSelect.options[containerSelect.selectedIndex];\n    showContainerDetails(opt);\n  });\n  \n  createBtn?.addEventListener('click', createSnapshot);\n  \n  // Tab switching\n  modal?.querySelectorAll('.panel-tab').forEach(tab => {\n    tab.addEventListener('click', () => {\n      modal.querySelectorAll('.panel-tab').forEach(t => t.classList.remove('active'));\n      modal.querySelectorAll('.panel-section').forEach(s => s.classList.remove('active'));\n      tab.classList.add('active');\n      modal.querySelector(`#${tab.dataset.panel}`).classList.add('active');\n    });\n  });\n})();\n;\n// ========== SMART ARR CONNECT ==========\n(function() {\n  injectModal('arr-setup-modal', `<div id=\"arr-setup-modal\" class=\"weather-modal\">\n    <div class=\"weather-modal-content\" style=\"min-width: 600px; max-width: 720px;\">\n      <h3>\uD83C\uDFAC Smart Arr Connect</h3>\n      <p style=\"color: var(--muted); margin: 0 0 16px; font-size: 0.9rem;\">\n        Auto-discover and connect your entire media stack.\n      </p>\n\n      <!-- Phase 1: Detection -->\n      <div id=\"smart-phase-detect\">\n        <div style=\"text-align: center; padding: 20px;\">\n          <span class=\"brand-spinner\" style=\"margin-bottom: 12px; display: inline-block;\"></span>\n          <div style=\"color: var(--muted); font-size: 0.9rem;\">Scanning for services...</div>\n        </div>\n        <div id=\"smart-detect-results\" style=\"display: none;\"></div>\n      </div>\n\n      <!-- Phase 2: Credential Input (only for services needing keys) -->\n      <div id=\"smart-phase-credentials\" style=\"display: none;\">\n        <h4 class=\"heading-accent-section\">Enter Missing API Keys</h4>\n        <div id=\"smart-credential-inputs\"></div>\n\n        <!-- Connection Options -->\n        <div style=\"margin-top: 16px; padding: 12px; background: var(--card-base); border-radius: 8px; border: 1px solid var(--border);\">\n          <h4 style=\"margin: 0 0 10px; font-size: 0.85rem; color: var(--accent);\">Connection Options</h4>\n          <label class=\"option-label\">\n            <input type=\"checkbox\" id=\"smart-opt-seerr\" checked class=\"checkbox-sm\" />\n            Configure Seerr with Radarr + Sonarr\n          </label>\n          <label class=\"option-label\">\n            <input type=\"checkbox\" id=\"smart-opt-plex\" checked class=\"checkbox-sm\" />\n            Connect Plex to Seerr\n          </label>\n          <label class=\"option-label\">\n            <input type=\"checkbox\" id=\"smart-opt-prowlarr\" checked class=\"checkbox-sm\" />\n            Connect Prowlarr to Radarr + Sonarr\n          </label>\n          <label style=\"display: flex; align-items: center; gap: 8px; cursor: pointer; font-size: 0.85rem;\">\n            <input type=\"checkbox\" id=\"smart-opt-save\" checked class=\"checkbox-sm\" />\n            Save API keys for one-click reconnect\n          </label>\n        </div>\n\n        <button id=\"smart-connect-btn\" style=\"width: 100%; margin-top: 16px; padding: 12px; background: linear-gradient(135deg, #e74c3c 0%, #9b59b6 100%); border: none; color: white; font-weight: 600; font-size: 1rem; border-radius: 8px; cursor: pointer;\">\n          Smart Connect\n        </button>\n      </div>\n\n      <!-- Phase 3: Connection Progress -->\n      <div id=\"smart-phase-progress\" style=\"display: none;\">\n        <h4 class=\"heading-accent-section\">Connecting Everything...</h4>\n        <div id=\"smart-progress-steps\" style=\"display: flex; flex-direction: column; gap: 6px;\"></div>\n      </div>\n\n      <!-- Phase 4: Results -->\n      <div id=\"smart-phase-results\" style=\"display: none;\">\n        <div id=\"smart-results-content\"></div>\n        <div id=\"smart-plex-libraries\" style=\"display: none; margin-top: 12px;\"></div>\n        <div style=\"display: flex; gap: 8px; margin-top: 16px;\">\n          <button id=\"smart-retry-btn\" style=\"display: none; flex: 1; padding: 10px; background: #f39c12; border: none; color: white; font-weight: 500; border-radius: 8px; cursor: pointer;\">\n            Retry Failed Steps\n          </button>\n          <a id=\"smart-open-seerr\" href=\"#\" target=\"_blank\" rel=\"noopener noreferrer\"\n             style=\"flex: 1; padding: 10px; background: var(--accent); color: white; border: none; border-radius: 8px; cursor: pointer; font-weight: 500; text-decoration: none; text-align: center;\">\n            Open Seerr\n          </a>\n        </div>\n      </div>\n\n      <!-- Help Text -->\n      <div style=\"font-size: 0.75rem; color: var(--muted); margin-top: 12px; padding: 10px; background: color-mix(in srgb, var(--accent) 5%, transparent); border-radius: 6px;\">\n        <strong>Where to find API keys:</strong><br>\n        Radarr/Sonarr/Prowlarr: Settings -> General -> Security -> API Key\n      </div>\n\n      <!-- Close Button -->\n      <div class=\"weather-modal-buttons modal-footer-bar\">\n        <button id=\"arr-setup-cancel\">Close</button>\n      </div>\n    </div>\n  </div>`);\n\n  const modal = document.getElementById('arr-setup-modal');\n  const openBtn = document.getElementById('arr-setup-btn');\n  const cancelBtn = document.getElementById('arr-setup-cancel');\n  const connectBtn = document.getElementById('smart-connect-btn');\n\n  // Phase elements\n  const phaseDetect = document.getElementById('smart-phase-detect');\n  const phaseCredentials = document.getElementById('smart-phase-credentials');\n  const phaseProgress = document.getElementById('smart-phase-progress');\n  const phaseResults = document.getElementById('smart-phase-results');\n\n  const detectResults = document.getElementById('smart-detect-results');\n  const credentialInputs = document.getElementById('smart-credential-inputs');\n  const progressSteps = document.getElementById('smart-progress-steps');\n  const resultsContent = document.getElementById('smart-results-content');\n  const plexLibraries = document.getElementById('smart-plex-libraries');\n  const retryBtn = document.getElementById('smart-retry-btn');\n\n  let detectedData = null; // Store detection results for smart-connect\n\n  const serviceIcons = { plex: '\uD83C\uDFAC', radarr: '\uD83C\uDFAC', sonarr: '\uD83D\uDCFA', prowlarr: '\uD83D\uDD0D', seerr: '\uD83D\uDCCB' };\n  const serviceLabels = { plex: 'Plex', radarr: 'Radarr (Movies)', sonarr: 'Sonarr (TV)', prowlarr: 'Prowlarr (Indexers)', seerr: 'Seerr' };\n\n  function showPhase(phase) {\n    phaseDetect.style.display = phase === 'detect' ? 'block' : 'none';\n    phaseCredentials.style.display = phase === 'credentials' ? 'block' : 'none';\n    phaseProgress.style.display = phase === 'progress' ? 'block' : 'none';\n    phaseResults.style.display = phase === 'results' ? 'block' : 'none';\n  }\n\n  function statusBadge(status) {\n    const colors = {\n      connected: { bg: 'var(--ok-fg)', icon: '&#10003;', text: 'Connected' },\n      needs_key: { bg: '#f39c12', icon: '&#128273;', text: 'Needs API Key' },\n      not_found: { bg: 'var(--muted)', icon: '&mdash;', text: 'Not Found' },\n      error: { bg: 'var(--bad-fg)', icon: '&#10007;', text: 'Error' }\n    };\n    const c = colors[status] || colors.not_found;\n    return `<span style=\"display: inline-flex; align-items: center; gap: 4px; padding: 2px 8px; border-radius: 4px; font-size: 0.75rem; background: color-mix(in srgb, ${c.bg} 20%, transparent); color: ${c.bg};\">${c.icon} ${c.text}</span>`;\n  }\n\n  // Phase 1: Smart Detection\n  async function smartDetect() {\n    showPhase('detect');\n    detectResults.style.display = 'none';\n\n    try {\n      const response = await fetch('/api/v1/arr/smart-detect');\n      detectedData = await response.json();\n\n      if (!detectedData.success) {\n        detectResults.innerHTML = `<div style=\"padding: 12px; color: var(--bad-fg);\">Detection failed: ${escapeHtml(detectedData.error)}</div>`;\n        detectResults.style.display = 'block';\n        return;\n      }\n\n      // Render detection results\n      let html = '<div style=\"display: flex; flex-direction: column; gap: 8px;\">';\n\n      for (const [svc, info] of Object.entries(detectedData.services)) {\n        const icon = serviceIcons[svc] || '\uD83D\uDCE6';\n        const label = serviceLabels[svc] || svc;\n        const source = info.source ? `<span style=\"font-size: 0.7rem; color: var(--muted); padding: 1px 6px; background: var(--card-bg); border-radius: 3px;\">${escapeHtml(info.source)}</span>` : '';\n        const version = info.version ? `<span style=\"font-size: 0.7rem; color: var(--muted);\">v${escapeHtml(info.version)}</span>` : '';\n        const keySaved = (info.hasApiKey || info.hasToken) && info.status === 'connected'\n          ? '<span style=\"font-size: 0.7rem; color: var(--ok-fg);\">Key saved</span>' : '';\n\n        html += `<div style=\"display: flex; align-items: center; gap: 10px; padding: 10px 12px; background: var(--card-base); border-radius: 8px; border: 1px solid var(--border);\">\n          <span style=\"font-size: 1.1rem;\">${icon}</span>\n          <div style=\"flex: 1;\">\n            <div style=\"font-weight: 500; font-size: 0.9rem;\">${label}</div>\n            <div style=\"display: flex; gap: 6px; align-items: center; flex-wrap: wrap;\">\n              ${source} ${version} ${keySaved}\n            </div>\n          </div>\n          ${statusBadge(info.status)}\n        </div>`;\n      }\n\n      html += '</div>';\n\n      // Summary\n      const s = detectedData.summary;\n      html += `<div style=\"margin-top: 12px; padding: 10px; background: color-mix(in srgb, var(--accent) 8%, transparent); border-radius: 8px; font-size: 0.85rem;\">\n        ${escapeHtml(String(s.fullyConnected))}/${escapeHtml(String(s.totalDetected + (5 - s.totalDetected)))} services detected &middot;\n        ${escapeHtml(String(s.fullyConnected))} connected${s.needsApiKey > 0 ? ` &middot; <strong>${escapeHtml(String(s.needsApiKey))} needs API key</strong>` : ''}\n      </div>`;\n\n      detectResults.innerHTML = html;\n      detectResults.style.display = 'block';\n\n      // Build credential inputs for services that need keys\n      buildCredentialInputs(detectedData);\n\n      // Auto-advance after a short delay\n      setTimeout(() => {\n        showPhase('credentials');\n      }, 800);\n\n    } catch (e) {\n      detectResults.innerHTML = `<div style=\"padding: 12px; color: var(--bad-fg);\">Error: ${escapeHtml(e.message)}</div>`;\n      detectResults.style.display = 'block';\n    }\n  }\n\n  // Build credential input fields\n  function buildCredentialInputs(data) {\n    let html = '';\n    const services = data.services;\n    const arrServices = ['radarr', 'sonarr', 'prowlarr'];\n\n    for (const svc of arrServices) {\n      const info = services[svc];\n      if (!info || info.status === 'not_found' && !info.url) continue;\n\n      const icon = serviceIcons[svc];\n      const label = serviceLabels[svc];\n      const isConnected = info.status === 'connected';\n      const borderColor = isConnected ? 'var(--ok-fg)' : 'var(--border)';\n\n      html += `<div style=\"margin-bottom: 10px; padding: 12px; background: var(--card-base); border-radius: 8px; border: 1px solid ${borderColor};\">\n        <div style=\"display: flex; align-items: center; gap: 8px; margin-bottom: 8px;\">\n          <span style=\"font-size: 1.1rem;\">${icon}</span>\n          <span style=\"font-weight: 500;\">${label}</span>\n          <span id=\"smart-${svc}-status\" style=\"margin-left: auto; font-size: 0.75rem;\">\n            ${isConnected ? '<span style=\"color: var(--ok-fg);\">&#10003; Connected</span>' : ''}\n          </span>\n        </div>\n        <div style=\"display: grid; grid-template-columns: 2fr 1fr; gap: 8px;\">\n          <div>\n            <label style=\"font-size: 0.75rem; color: var(--muted);\">URL:</label>\n            <input type=\"text\" id=\"smart-${svc}-url\" value=\"${escapeHtml(info.url || '')}\" placeholder=\"https://seedbox.com/${svc}/\"\n                   style=\"width: 100%; font-size: 0.85rem; padding: 6px 8px; background: var(--card-bg); color: var(--fg); border: 1px solid var(--border); border-radius: 4px;\" />\n          </div>\n          <div>\n            <label style=\"font-size: 0.75rem; color: var(--muted);\">API Key:</label>\n            <input type=\"password\" id=\"smart-${svc}-key\" placeholder=\"${isConnected ? '(saved)' : 'Paste API key'}\"\n                   style=\"width: 100%; font-size: 0.85rem; padding: 6px 8px; background: var(--card-bg); color: var(--fg); border: 1px solid var(--border); border-radius: 4px;\" />\n          </div>\n        </div>\n        <button onclick=\"smartTestConnection('${svc}')\" style=\"margin-top: 8px; padding: 4px 12px; font-size: 0.75rem; cursor: pointer;\">Test</button>\n      </div>`;\n    }\n\n    // Plex status (non-editable, just shows status)\n    const plex = services.plex;\n    if (plex) {\n      const plexConnected = plex.status === 'connected';\n      html += `<div style=\"padding: 10px 12px; background: var(--card-base); border-radius: 8px; border: 1px solid ${plexConnected ? 'var(--ok-fg)' : 'var(--border)'}; margin-bottom: 10px;\">\n        <div style=\"display: flex; align-items: center; gap: 8px;\">\n          <span style=\"font-size: 1.1rem;\">\uD83C\uDFAC</span>\n          <span style=\"font-weight: 500;\">Plex</span>\n          ${statusBadge(plex.status)}\n          <span style=\"margin-left: auto; font-size: 0.75rem; color: var(--muted);\">${escapeHtml(plex.source || '')}</span>\n        </div>\n      </div>`;\n    }\n\n    // Seerr status\n    const seerr = services.seerr;\n    if (seerr) {\n      const seerrOk = seerr.status === 'connected';\n      let configuredHtml = '';\n      if (seerr.configuredServices) {\n        const cs = seerr.configuredServices;\n        configuredHtml = `<div style=\"font-size: 0.75rem; color: var(--muted); margin-top: 4px;\">\n          Configured: ${cs.radarr ? '&#10003; Radarr' : '&#10007; Radarr'} &middot;\n          ${cs.sonarr ? '&#10003; Sonarr' : '&#10007; Sonarr'} &middot;\n          ${cs.plex ? '&#10003; Plex' : '&#10007; Plex'}\n        </div>`;\n      }\n      html += `<div style=\"padding: 10px 12px; background: var(--card-base); border-radius: 8px; border: 1px solid ${seerrOk ? 'var(--ok-fg)' : 'var(--border)'};\">\n        <div style=\"display: flex; align-items: center; gap: 8px;\">\n          <span style=\"font-size: 1.1rem;\">\uD83D\uDCCB</span>\n          <span style=\"font-weight: 500;\">Seerr</span>\n          ${statusBadge(seerr.status)}\n        </div>\n        ${configuredHtml}\n      </div>`;\n    }\n\n    credentialInputs.innerHTML = html;\n  }\n\n  // Test connection (global for onclick)\n  window.smartTestConnection = async function(service) {\n    const urlInput = document.getElementById(`smart-${service}-url`);\n    const keyInput = document.getElementById(`smart-${service}-key`);\n    const statusSpan = document.getElementById(`smart-${service}-status`);\n\n    const url = urlInput?.value.trim();\n    const apiKey = keyInput?.value.trim();\n\n    if (!url || !apiKey) {\n      statusSpan.innerHTML = '<span style=\"color: var(--bad-fg);\">Enter URL and API key</span>';\n      return;\n    }\n\n    statusSpan.innerHTML = '<span class=\"brand-spinner\"></span>';\n\n    try {\n      const response = await secureFetch('/api/v1/arr/test-connection', {\n        method: 'POST',\n        headers: { 'Content-Type': 'application/json' },\n        body: JSON.stringify({ service, url, apiKey })\n      });\n      const data = await response.json();\n      if (data.success) {\n        statusSpan.innerHTML = `<span style=\"color: var(--ok-fg);\">&#10003; ${escapeHtml(data.appName || 'Connected')} v${escapeHtml(data.version || '')}</span>`;\n      } else {\n        statusSpan.innerHTML = `<span style=\"color: var(--bad-fg);\">&#10007; ${escapeHtml(data.error)}</span>`;\n      }\n    } catch (e) {\n      statusSpan.innerHTML = `<span style=\"color: var(--bad-fg);\">&#10007; ${escapeHtml(e.message)}</span>`;\n    }\n  };\n\n  // Phase 3: Smart Connect\n  async function smartConnect() {\n    showPhase('progress');\n    progressSteps.innerHTML = '<div style=\"text-align: center; padding: 20px;\"><span class=\"brand-spinner\"></span><div style=\"color: var(--muted); margin-top: 8px;\">Connecting services...</div></div>';\n\n    // Gather input\n    const services = {};\n    for (const svc of ['radarr', 'sonarr', 'prowlarr']) {\n      const url = document.getElementById(`smart-${svc}-url`)?.value.trim();\n      const apiKey = document.getElementById(`smart-${svc}-key`)?.value.trim();\n      if (apiKey && url) {\n        services[svc] = { apiKey, url };\n      } else if (apiKey) {\n        // Key provided without URL - let backend resolve\n        services[svc] = { apiKey };\n      }\n      // If no key entered but service was already connected, backend uses stored credentials\n    }\n\n    const payload = {\n      services: Object.keys(services).length > 0 ? services : undefined,\n      configurePlex: document.getElementById('smart-opt-plex')?.checked,\n      configureProwlarr: document.getElementById('smart-opt-prowlarr')?.checked,\n      configureSeerr: document.getElementById('smart-opt-seerr')?.checked,\n      saveCredentials: document.getElementById('smart-opt-save')?.checked\n    };\n\n    try {\n      const response = await secureFetch('/api/v1/arr/smart-connect', {\n        method: 'POST',\n        headers: { 'Content-Type': 'application/json' },\n        body: JSON.stringify(payload)\n      });\n\n      const data = await response.json();\n\n      // Render progress steps\n      let stepsHtml = '';\n      for (const step of (data.steps || [])) {\n        const icon = step.status === 'success' ? '<span style=\"color: var(--ok-fg);\">&#10003;</span>'\n                   : '<span style=\"color: var(--bad-fg);\">&#10007;</span>';\n        const detailColor = step.status === 'success' ? 'var(--muted)' : 'var(--bad-fg)';\n        stepsHtml += `<div style=\"display: flex; align-items: center; gap: 8px; padding: 6px 10px; background: var(--card-base); border-radius: 6px; font-size: 0.85rem;\">\n          ${icon}\n          <span>${escapeHtml(step.step)}</span>\n          <span style=\"margin-left: auto; font-size: 0.75rem; color: ${detailColor};\">${escapeHtml(step.details || '')}</span>\n        </div>`;\n      }\n      progressSteps.innerHTML = stepsHtml;\n\n      // Show results after brief delay\n      setTimeout(() => showResults(data), 500);\n\n    } catch (e) {\n      progressSteps.innerHTML = `<div style=\"padding: 12px; color: var(--bad-fg);\">Connection error: ${escapeHtml(e.message)}</div>`;\n    }\n  }\n\n  // Phase 4: Results\n  function showResults(data) {\n    showPhase('results');\n\n    const s = data.summary || {};\n    const allGood = s.failed === 0 && s.succeeded > 0;\n    const headerColor = allGood ? 'var(--ok-fg)' : '#f39c12';\n    const headerIcon = allGood ? '&#10003;' : '&#9888;';\n    const headerText = allGood ? 'All Connected!' : `${escapeHtml(String(s.succeeded))}/${escapeHtml(String(s.totalSteps))} Steps Succeeded`;\n\n    let html = `<div style=\"text-align: center; padding: 16px; background: color-mix(in srgb, ${headerColor} 12%, transparent); border-radius: 10px; border: 1px solid ${headerColor}; margin-bottom: 12px;\">\n      <div style=\"font-size: 1.5rem; color: ${headerColor};\">${headerIcon}</div>\n      <div style=\"font-size: 1.1rem; font-weight: 600; color: ${headerColor};\">${headerText}</div>\n      <div style=\"font-size: 0.85rem; color: var(--muted); margin-top: 4px;\">${escapeHtml(String(s.succeeded))} succeeded, ${escapeHtml(String(s.failed))} failed</div>\n    </div>`;\n\n    // Steps detail\n    html += '<div style=\"display: flex; flex-direction: column; gap: 4px;\">';\n    for (const step of (data.steps || [])) {\n      const icon = step.status === 'success' ? '<span style=\"color: var(--ok-fg);\">&#10003;</span>'\n                 : '<span style=\"color: var(--bad-fg);\">&#10007;</span>';\n      html += `<div style=\"display: flex; align-items: center; gap: 8px; padding: 4px 8px; font-size: 0.8rem;\">\n        ${icon} ${escapeHtml(step.step)} <span style=\"margin-left: auto; color: var(--muted); font-size: 0.75rem;\">${escapeHtml(step.details || '')}</span>\n      </div>`;\n    }\n    html += '</div>';\n\n    resultsContent.innerHTML = html;\n\n    // Show retry button if any failures\n    retryBtn.style.display = s.failed > 0 ? 'block' : 'none';\n\n    // Fetch Plex libraries if Plex was connected\n    if (data.steps?.some(st => st.step.includes('Plex') && st.status === 'success')) {\n      fetchPlexLibraries();\n    }\n  }\n\n  async function fetchPlexLibraries() {\n    try {\n      const res = await fetch('/api/v1/plex/libraries');\n      const data = await res.json();\n      if (data.success && data.libraries?.length > 0) {\n        let html = `<div style=\"padding: 12px; background: var(--card-base); border-radius: 8px; border: 1px solid var(--border);\">\n          <h4 style=\"margin: 0 0 8px; font-size: 0.85rem; color: var(--accent);\">\uD83C\uDFAC ${escapeHtml(data.serverName)} Libraries</h4>\n          <div style=\"display: flex; flex-wrap: wrap; gap: 8px;\">`;\n        for (const lib of data.libraries) {\n          const typeIcon = lib.type === 'movie' ? '\uD83C\uDFAC' : lib.type === 'show' ? '\uD83D\uDCFA' : '\uD83C\uDFB5';\n          html += `<div style=\"padding: 8px 12px; background: var(--card-bg); border-radius: 6px; font-size: 0.85rem;\">\n            ${typeIcon} <strong>${escapeHtml(lib.title)}</strong>\n            <span style=\"color: var(--muted); font-size: 0.75rem;\">${escapeHtml(String(lib.count))} items</span>\n          </div>`;\n        }\n        html += '</div></div>';\n        plexLibraries.innerHTML = html;\n        plexLibraries.style.display = 'block';\n      }\n    } catch (e) {\n      // Ignore Plex library fetch errors\n    }\n  }\n\n  // Event listeners\n  openBtn?.addEventListener('click', () => {\n    modal.classList.add('show');\n    plexLibraries.style.display = 'none';\n    smartDetect();\n  });\n\n  wireModal(modal, cancelBtn);\n  connectBtn?.addEventListener('click', smartConnect);\n  retryBtn?.addEventListener('click', smartConnect);\n})();\n;\n// ========== NOTIFICATION SETTINGS ==========\n(function() {\n  const errorHandler = new ErrorHandler();\n  // Inject modal HTML\n  injectModal('notifications-modal', `<div id=\"notifications-modal\" class=\"weather-modal\">\n    <div class=\"weather-modal-content\" style=\"min-width: 550px; max-width: 650px;\">\n      <h3>\uD83D\uDD14 Notification Settings</h3>\n\n      <!-- Master Toggle -->\n      <div class=\"accent-info-box\">\n        <label style=\"display: flex; align-items: center; gap: 10px; cursor: pointer;\">\n          <input type=\"checkbox\" id=\"notifications-enabled\" />\n          <div>\n            <span style=\"font-weight: 600; color: var(--accent);\">Enable Notifications</span>\n            <div class=\"text-tiny-muted\">Receive alerts when containers go up/down</div>\n          </div>\n        </label>\n      </div>\n\n      <!-- Providers Section -->\n      <h4 class=\"section-heading\">Notification Providers</h4>\n\n      <!-- Discord -->\n      <div class=\"notification-provider provider-card\">\n        <div class=\"provider-header\">\n          <label class=\"checkbox-label\">\n            <input type=\"checkbox\" id=\"discord-enabled\" />\n            <span class=\"fw-500\">Discord</span>\n          </label>\n          <button id=\"discord-test\" class=\"test-btn btn-xs\">Test</button>\n        </div>\n        <div id=\"discord-config\" style=\"display: none;\">\n          <label class=\"field-label-sm\">Webhook URL:</label>\n          <input type=\"text\" id=\"discord-webhook\" placeholder=\"https://discord.com/api/v1/webhooks/...\" style=\"width: 100%;\" />\n        </div>\n      </div>\n\n      <!-- Telegram -->\n      <div class=\"notification-provider provider-card\">\n        <div class=\"provider-header\">\n          <label class=\"checkbox-label\">\n            <input type=\"checkbox\" id=\"telegram-enabled\" />\n            <span class=\"fw-500\">Telegram</span>\n          </label>\n          <button id=\"telegram-test\" class=\"test-btn btn-xs\">Test</button>\n        </div>\n        <div id=\"telegram-config\" style=\"display: none;\">\n          <div class=\"grid-2col\">\n            <div>\n              <label class=\"field-label-sm\">Bot Token:</label>\n              <input type=\"text\" id=\"telegram-bot-token\" placeholder=\"123456:ABC...\" />\n            </div>\n            <div>\n              <label class=\"field-label-sm\">Chat ID:</label>\n              <input type=\"text\" id=\"telegram-chat-id\" placeholder=\"-1001234567890\" />\n            </div>\n          </div>\n        </div>\n      </div>\n\n      <!-- ntfy.sh -->\n      <div class=\"notification-provider provider-card\">\n        <div class=\"provider-header\">\n          <label class=\"checkbox-label\">\n            <input type=\"checkbox\" id=\"ntfy-enabled\" />\n            <span class=\"fw-500\">ntfy.sh</span>\n          </label>\n          <button id=\"ntfy-test\" class=\"test-btn btn-xs\">Test</button>\n        </div>\n        <div id=\"ntfy-config\" style=\"display: none;\">\n          <div style=\"display: grid; grid-template-columns: 2fr 1fr; gap: 8px;\">\n            <div>\n              <label class=\"field-label-sm\">Server URL:</label>\n              <input type=\"text\" id=\"ntfy-server\" placeholder=\"https://ntfy.sh\" value=\"https://ntfy.sh\" />\n            </div>\n            <div>\n              <label class=\"field-label-sm\">Topic:</label>\n              <input type=\"text\" id=\"ntfy-topic\" placeholder=\"dashcaddy-alerts\" />\n            </div>\n          </div>\n        </div>\n      </div>\n\n      <!-- Email -->\n      <div class=\"notification-provider provider-card\">\n        <div class=\"provider-header\">\n          <label class=\"checkbox-label\">\n            <input type=\"checkbox\" id=\"email-enabled\" />\n            <span class=\"fw-500\">Email (SMTP)</span>\n          </label>\n          <button id=\"email-test\" class=\"test-btn btn-xs\">Test</button>\n        </div>\n        <div id=\"email-config\" style=\"display: none;\">\n          <div style=\"display: grid; grid-template-columns: 2fr 1fr; gap: 8px; margin-bottom: 8px;\">\n            <div>\n              <label class=\"field-label-sm\">SMTP Host:</label>\n              <input type=\"text\" id=\"email-host\" placeholder=\"smtp.gmail.com\" />\n            </div>\n            <div>\n              <label class=\"field-label-sm\">Port:</label>\n              <input type=\"number\" id=\"email-port\" value=\"587\" placeholder=\"587\" />\n            </div>\n          </div>\n          <div style=\"display: grid; grid-template-columns: 1fr 1fr; gap: 8px; margin-bottom: 8px;\">\n            <div>\n              <label class=\"field-label-sm\">Username:</label>\n              <input type=\"text\" id=\"email-user\" placeholder=\"user@gmail.com\" />\n            </div>\n            <div>\n              <label class=\"field-label-sm\">Password:</label>\n              <input type=\"password\" id=\"email-pass\" placeholder=\"app password\" />\n            </div>\n          </div>\n          <div style=\"display: grid; grid-template-columns: 1fr 1fr; gap: 8px;\">\n            <div>\n              <label class=\"field-label-sm\">From:</label>\n              <input type=\"text\" id=\"email-from\" placeholder=\"DashCaddy &lt;noreply@example.com&gt;\" />\n            </div>\n            <div>\n              <label class=\"field-label-sm\">To:</label>\n              <input type=\"text\" id=\"email-to\" placeholder=\"admin@example.com\" />\n            </div>\n          </div>\n          <label style=\"display: flex; align-items: center; gap: 6px; margin-top: 8px; font-size: 0.8rem;\">\n            <input type=\"checkbox\" id=\"email-secure\" /> Use TLS (port 465)\n          </label>\n        </div>\n      </div>\n\n      <!-- Health Check Settings -->\n      <h4 class=\"section-heading\">Health Monitoring</h4>\n      <div style=\"padding: 12px; background: var(--card-base); border-radius: 8px; border: 1px solid var(--border);\">\n        <label style=\"display: flex; align-items: center; gap: 10px; cursor: pointer; margin-bottom: 10px;\">\n          <input type=\"checkbox\" id=\"health-check-enabled\" />\n          <div>\n            <span class=\"fw-500\">Enable Health Monitoring</span>\n            <div class=\"text-tiny-muted\">Periodically check container status</div>\n          </div>\n        </label>\n        <div id=\"health-check-config\" style=\"display: flex; align-items: center; gap: 10px;\">\n          <label class=\"field-label-sm\">Check interval:</label>\n          <select id=\"health-check-interval\" style=\"width: auto;\">\n            <option value=\"1\">1 minute</option>\n            <option value=\"5\" selected>5 minutes</option>\n            <option value=\"15\">15 minutes</option>\n            <option value=\"30\">30 minutes</option>\n            <option value=\"60\">1 hour</option>\n          </select>\n          <button id=\"health-check-now\" style=\"padding: 4px 10px; font-size: 0.75rem; margin-left: auto;\">Check Now</button>\n        </div>\n        <div id=\"health-check-status\" style=\"font-size: 0.75rem; color: var(--muted); margin-top: 8px;\">\n          Last check: Never\n        </div>\n      </div>\n\n      <!-- Event Types -->\n      <h4 class=\"section-heading\">Events to Notify</h4>\n      <div style=\"display: grid; grid-template-columns: 1fr 1fr; gap: 6px; padding: 12px; background: var(--card-base); border-radius: 8px; border: 1px solid var(--border);\">\n        <label class=\"checkbox-label-sm\">\n          <input type=\"checkbox\" id=\"event-container-down\" checked /> Container Down\n        </label>\n        <label class=\"checkbox-label-sm\">\n          <input type=\"checkbox\" id=\"event-container-up\" checked /> Container Recovered\n        </label>\n        <label class=\"checkbox-label-sm\">\n          <input type=\"checkbox\" id=\"event-deploy-success\" checked /> Deployment Success\n        </label>\n        <label class=\"checkbox-label-sm\">\n          <input type=\"checkbox\" id=\"event-deploy-failed\" checked /> Deployment Failed\n        </label>\n        <label class=\"checkbox-label-sm\">\n          <input type=\"checkbox\" id=\"event-ssl-cert-expiry\" checked /> SSL Expiry\n        </label>\n        <label class=\"checkbox-label-sm\">\n          <input type=\"checkbox\" id=\"event-dns-propagation\" checked /> DNS Propagation\n        </label>\n        <label class=\"checkbox-label-sm\">\n          <input type=\"checkbox\" id=\"event-drift-detected\" checked /> Config Drift\n        </label>\n        <label class=\"checkbox-label-sm\">\n          <input type=\"checkbox\" id=\"event-dependency-restart\" checked /> Dependency Restarts\n        </label>\n        <label class=\"checkbox-label-sm\">\n          <input type=\"checkbox\" id=\"event-recipe-removed\" checked /> Recipe Removed\n        </label>\n        <label class=\"checkbox-label-sm\">\n          <input type=\"checkbox\" id=\"event-workflow\" checked /> Workflow Actions\n        </label>\n        <label class=\"checkbox-label-sm\">\n          <input type=\"checkbox\" id=\"event-backup-complete\" checked /> Backup Complete\n        </label>\n        <label class=\"checkbox-label-sm\">\n          <input type=\"checkbox\" id=\"event-backup-failed\" checked /> Backup Failed\n        </label>\n        <label class=\"checkbox-label-sm\">\n          <input type=\"checkbox\" id=\"event-update-available\" checked /> Updates\n        </label>\n        <label class=\"checkbox-label-sm\" style=\"grid-column: 1 / -1;\">\n          <input type=\"checkbox\" id=\"event-resource-alert\" checked /> Resource Alerts\n        </label>\n      </div>\n\n      <!-- History -->\n      <h4 class=\"section-heading\">Notification History</h4>\n      <div id=\"notification-history\" style=\"max-height: 150px; overflow-y: auto; padding: 8px; background: var(--card-base); border-radius: 8px; border: 1px solid var(--border); font-size: 0.8rem;\">\n        <div style=\"color: var(--muted); text-align: center; padding: 20px;\">No notifications yet</div>\n      </div>\n      <div id=\"last-notification-sent\" style=\"font-size: 0.75rem; color: var(--muted); text-align: center; margin-top: 6px;\"></div>\n\n      <!-- Buttons -->\n      <div class=\"weather-modal-buttons modal-footer-bar\">\n        <button id=\"notifications-send-test\" class=\"btn-secondary\" style=\"margin-right: auto;\">Send Test</button>\n        <button id=\"notifications-cancel\">Cancel</button>\n        <button id=\"notifications-save\" class=\"btn-accent\">Save Settings</button>\n      </div>\n    </div>\n  </div>`);\n\n  const modal = document.getElementById('notifications-modal');\n  const openBtn = document.getElementById('manage-notifications');\n  const saveBtn = document.getElementById('notifications-save');\n  const cancelBtn = document.getElementById('notifications-cancel');\n\n  // Provider toggle handlers\n  ['discord', 'telegram', 'ntfy', 'email'].forEach(provider => {\n    const checkbox = document.getElementById(`${provider}-enabled`);\n    const config = document.getElementById(`${provider}-config`);\n\n    checkbox?.addEventListener('change', () => {\n      config.style.display = checkbox.checked ? 'block' : 'none';\n    });\n  });\n\n  // Health check toggle\n  const healthCheckEnabled = document.getElementById('health-check-enabled');\n  const healthCheckConfig = document.getElementById('health-check-config');\n  healthCheckEnabled?.addEventListener('change', () => {\n    healthCheckConfig.style.opacity = healthCheckEnabled.checked ? '1' : '0.5';\n  });\n\n  // Load notification config from API\n  async function loadNotificationConfig() {\n    try {\n      const response = await fetch('/api/v1/notifications/config');\n      const data = await response.json();\n\n      if (data.success) {\n        const config = data.config;\n\n        // Master toggle\n        document.getElementById('notifications-enabled').checked = config.enabled;\n\n        // Providers\n        document.getElementById('discord-enabled').checked = config.providers?.discord?.enabled || false;\n        document.getElementById('telegram-enabled').checked = config.providers?.telegram?.enabled || false;\n        document.getElementById('ntfy-enabled').checked = config.providers?.ntfy?.enabled || false;\n        document.getElementById('email-enabled').checked = config.providers?.email?.enabled || false;\n\n        // Show/hide config sections\n        document.getElementById('discord-config').style.display = config.providers?.discord?.enabled ? 'block' : 'none';\n        document.getElementById('telegram-config').style.display = config.providers?.telegram?.enabled ? 'block' : 'none';\n        document.getElementById('ntfy-config').style.display = config.providers?.ntfy?.enabled ? 'block' : 'none';\n        document.getElementById('email-config').style.display = config.providers?.email?.enabled ? 'block' : 'none';\n\n        // ntfy server URL\n        if (config.providers?.ntfy?.serverUrl) {\n          document.getElementById('ntfy-server').value = config.providers.ntfy.serverUrl;\n        }\n\n        // email fields \u2014 DC-092: prefill the FULL form so a save doesn't\n        // silently wipe fields the GET response previously omitted. Password\n        // is never returned; when one is stored the field shows a keep-hint\n        // and an empty submit preserves the stored credential server-side.\n        if (config.providers?.email?.host) document.getElementById('email-host').value = config.providers.email.host;\n        if (config.providers?.email?.from) document.getElementById('email-from').value = config.providers.email.from;\n        if (config.providers?.email?.to) document.getElementById('email-to').value = config.providers.email.to;\n        if (config.providers?.email?.port) document.getElementById('email-port').value = config.providers.email.port;\n        if (config.providers?.email?.secure !== undefined) document.getElementById('email-secure').checked = config.providers.email.secure === true;\n        if (config.providers?.email?.username) document.getElementById('email-user').value = config.providers.email.username;\n        const emailPassEl = document.getElementById('email-pass');\n        if (config.providers?.email?.hasPassword) {\n          emailPassEl.value = '';\n          emailPassEl.placeholder = 'saved \u2014 leave blank to keep';\n        } else {\n          emailPassEl.placeholder = 'app password';\n        }\n\n        // Health check\n        document.getElementById('health-check-enabled').checked = config.healthCheck?.enabled || false;\n        if (config.healthCheck?.intervalMinutes) {\n          document.getElementById('health-check-interval').value = config.healthCheck.intervalMinutes;\n        }\n        if (config.healthCheck?.lastCheck) {\n          document.getElementById('health-check-status').textContent =\n            `Last check: ${new Date(config.healthCheck.lastCheck).toLocaleString()}`;\n        }\n\n        // Events \u2014 canonical kebab-case keys, matching the backend store\n        // (DC-092: previously read camelCase keys that never existed, so\n        // every toggle re-rendered as 'checked' regardless of stored state).\n        document.getElementById('event-container-down').checked = config.events?.['container-down'] !== false;\n        document.getElementById('event-container-up').checked = config.events?.['container-up'] === true;\n        document.getElementById('event-deploy-success').checked = config.events?.['deploy-success'] !== false;\n        document.getElementById('event-deploy-failed').checked = config.events?.['deploy-failed'] !== false;\n        document.getElementById('event-ssl-cert-expiry').checked = config.events?.['ssl-cert-expiry'] !== false;\n        document.getElementById('event-dns-propagation').checked = config.events?.['dns-propagation'] !== false;\n        document.getElementById('event-drift-detected').checked = config.events?.['drift-detected'] !== false;\n        document.getElementById('event-dependency-restart').checked = config.events?.['dependency-restart'] !== false;\n        document.getElementById('event-recipe-removed').checked = config.events?.['recipe-removed'] !== false;\n        document.getElementById('event-workflow').checked = config.events?.['workflow'] !== false;\n        document.getElementById('event-backup-complete').checked = config.events?.['backup-complete'] !== false;\n        document.getElementById('event-backup-failed').checked = config.events?.['backup-failed'] !== false;\n        document.getElementById('event-update-available').checked = config.events?.['update-available'] !== false;\n        document.getElementById('event-resource-alert').checked = config.events?.['alert'] !== false;\n      }\n    } catch (error) {\n      errorHandler.logError('[Notifications] Load Config', error, { function: 'loadConfig' });\n    }\n  }\n\n  // Load notification history\n  async function loadNotificationHistory() {\n    try {\n      const response = await fetch('/api/v1/notifications/history?limit=10');\n      const data = await response.json();\n\n      const container = document.getElementById('notification-history');\n      if (data.success && data.history?.length > 0) {\n        container.innerHTML = data.history.map(item => {\n          const date = new Date(item.timestamp).toLocaleString();\n          const typeColors = {\n            success: 'var(--ok-fg)',\n            error: 'var(--bad-fg)',\n            warning: '#f39c12',\n            info: 'var(--accent)'\n          };\n          return `\n            <div style=\"padding: 6px 8px; border-bottom: 1px solid var(--border); display: flex; gap: 8px; align-items: flex-start;\">\n              <span style=\"color: ${typeColors[item.type] || 'var(--muted)'}\">${item.type === 'success' ? '\u2713' : item.type === 'error' ? '\u2717' : '\u2139'}</span>\n              <div style=\"flex: 1; min-width: 0;\">\n                <div style=\"font-weight: 500; white-space: nowrap; overflow: hidden; text-overflow: ellipsis;\">${escapeHtml(item.title)}</div>\n                <div style=\"font-size: 0.7rem; color: var(--muted);\">${date}</div>\n              </div>\n            </div>\n          `;\n        }).join('');\n      } else {\n        container.innerHTML = '<div style=\"color: var(--muted); text-align: center; padding: 20px;\">No notifications yet</div>';\n      }\n    } catch (error) {\n      errorHandler.logError('[Notifications] Load History', error, { function: 'loadHistory' });\n    }\n  }\n\n  // Save notification config\n  async function saveNotificationConfig() {\n    try {\n      const config = {\n        enabled: document.getElementById('notifications-enabled').checked,\n        providers: {\n          discord: {\n            enabled: document.getElementById('discord-enabled').checked,\n            webhookUrl: document.getElementById('discord-webhook').value.trim()\n          },\n          telegram: {\n            enabled: document.getElementById('telegram-enabled').checked,\n            botToken: document.getElementById('telegram-bot-token').value.trim(),\n            chatId: document.getElementById('telegram-chat-id').value.trim()\n          },\n          ntfy: {\n            enabled: document.getElementById('ntfy-enabled').checked,\n            serverUrl: document.getElementById('ntfy-server').value.trim() || 'https://ntfy.sh',\n            topic: document.getElementById('ntfy-topic').value.trim()\n          },\n          email: {\n            enabled: document.getElementById('email-enabled').checked,\n            host: document.getElementById('email-host').value.trim(),\n            port: parseInt(document.getElementById('email-port').value) || 587,\n            secure: document.getElementById('email-secure').checked,\n            username: document.getElementById('email-user').value.trim(),\n            password: document.getElementById('email-pass').value.trim(),\n            from: document.getElementById('email-from').value.trim(),\n            to: document.getElementById('email-to').value.trim()\n          }\n        },\n        events: {\n          'container-down': document.getElementById('event-container-down').checked,\n          'container-up': document.getElementById('event-container-up').checked,\n          'deploy-success': document.getElementById('event-deploy-success').checked,\n          'deploy-failed': document.getElementById('event-deploy-failed').checked,\n          'ssl-cert-expiry': document.getElementById('event-ssl-cert-expiry').checked,\n          'dns-propagation': document.getElementById('event-dns-propagation').checked,\n          'drift-detected': document.getElementById('event-drift-detected').checked,\n          'dependency-restart': document.getElementById('event-dependency-restart').checked,\n          'recipe-removed': document.getElementById('event-recipe-removed').checked,\n          'workflow': document.getElementById('event-workflow').checked,\n          'backup-complete': document.getElementById('event-backup-complete').checked,\n          'backup-failed': document.getElementById('event-backup-failed').checked,\n          'update-available': document.getElementById('event-update-available').checked,\n          'alert': document.getElementById('event-resource-alert').checked\n        },\n        healthCheck: {\n          enabled: document.getElementById('health-check-enabled').checked,\n          intervalMinutes: parseInt(document.getElementById('health-check-interval').value) || 5\n        }\n      };\n\n      const response = await secureFetch('/api/v1/notifications/config', {\n        method: 'POST',\n        headers: { 'Content-Type': 'application/json' },\n        body: JSON.stringify(config)\n      });\n\n      const data = await response.json();\n      if (data.success) {\n        showNotification('Notification settings saved', 'success', 3000);\n        modal.classList.remove('show');\n      } else {\n        showNotification(`Failed to save: ${data.error}`, 'error', 3000);\n      }\n    } catch (error) {\n      showNotification(`Error: ${error.message}`, 'error', 3000);\n    }\n  }\n\n  // Test notification handlers\n  async function testProvider(provider) {\n    try {\n      const response = await secureFetch('/api/v1/notifications/test', {\n        method: 'POST',\n        headers: { 'Content-Type': 'application/json' },\n        body: JSON.stringify({ provider })\n      });\n\n      const data = await response.json();\n      if (data.success) {\n        showNotification(`Test ${provider} notification sent!`, 'success', 3000);\n      } else {\n        showNotification(`Test failed: ${data.error}`, 'error', 3000);\n      }\n    } catch (error) {\n      showNotification(`Error: ${error.message}`, 'error', 3000);\n    }\n  }\n\n  document.getElementById('discord-test')?.addEventListener('click', () => testProvider('discord'));\n  document.getElementById('telegram-test')?.addEventListener('click', () => testProvider('telegram'));\n  document.getElementById('ntfy-test')?.addEventListener('click', () => testProvider('ntfy'));\n  document.getElementById('email-test')?.addEventListener('click', () => testProvider('email'));\n\n  // Health check now button\n  document.getElementById('health-check-now')?.addEventListener('click', async () => {\n    try {\n      const response = await secureFetch('/api/v1/notifications/health-check', { method: 'POST' });\n      const data = await response.json();\n\n      if (data.success) {\n        document.getElementById('health-check-status').textContent =\n          `Last check: ${new Date(data.lastCheck).toLocaleString()} (${data.containersMonitored} containers)`;\n        showNotification('Health check completed', 'success', 2000);\n      }\n    } catch (error) {\n      showNotification(`Error: ${error.message}`, 'error', 3000);\n    }\n  });\n\n  // Modal handlers\n  openBtn?.addEventListener('click', () => {\n    modal.classList.add('show');\n    loadNotificationConfig();\n    loadNotificationHistory();\n  });\n\n  saveBtn?.addEventListener('click', saveNotificationConfig);\n\n  // Send Test button - sends test notification to all enabled providers\n  document.getElementById('notifications-send-test')?.addEventListener('click', async () => {\n    const btn = document.getElementById('notifications-send-test');\n    const originalText = btn.textContent;\n    btn.textContent = 'Sending...';\n    btn.disabled = true;\n\n    try {\n      const response = await secureFetch('/api/v1/notifications/send', {\n        method: 'POST',\n        headers: { 'Content-Type': 'application/json' },\n        body: JSON.stringify({ \n          event: 'test',\n          data: { message: 'This is a test notification from DashCaddy.' },\n          type: 'info'\n        })\n      });\n\n      const data = await response.json();\n      if (data.success) {\n        showNotification('Test notification sent!', 'success', 3000);\n        // Update last sent timestamp\n        loadNotificationStatus();\n      } else {\n        showNotification(`Test failed: ${data.results?.map(r => `${r.provider}: ${r.error || 'ok'}`).join(', ')}`, 'error', 5000);\n      }\n    } catch (error) {\n      showNotification(`Error: ${error.message}`, 'error', 3000);\n    } finally {\n      btn.textContent = originalText;\n      btn.disabled = false;\n    }\n  });\n\n  // Load notification status (last sent timestamp)\n  async function loadNotificationStatus() {\n    try {\n      const response = await fetch('/api/v1/notifications/status');\n      const data = await response.json();\n      if (data.success && data.lastSent) {\n        const lastSentEl = document.getElementById('last-notification-sent');\n        if (lastSentEl) {\n          lastSentEl.textContent = `Last sent: ${new Date(data.lastSent).toLocaleString()}`;\n        }\n      }\n    } catch (error) {\n      // Silently fail - status is not critical\n    }\n  }\n\n  wireModal(modal, cancelBtn);\n})();\n;\n// ========== PANEL TAB SWITCHING (shared utility) ==========\n(function() {\n  document.addEventListener('click', (e) => {\n    const tab = e.target.closest('.panel-tab');\n    if (!tab) return;\n    const panelId = tab.dataset.panel;\n    if (!panelId) return;\n    const tabBar = tab.closest('.panel-tabs');\n    const modalContent = tabBar.closest('.weather-modal-content');\n    tabBar.querySelectorAll('.panel-tab').forEach(t => t.classList.remove('active'));\n    tab.classList.add('active');\n    modalContent.querySelectorAll('.panel-section').forEach(s => s.classList.remove('active'));\n    const target = modalContent.querySelector('#' + panelId);\n    if (target) target.classList.add('active');\n  });\n})();\n;\n// ========== UNIFIED BACKUP/RESTORE v2.0 ==========\n// Single file captures everything: server config + browser state + themes + encryption key\n(function() {\n  // All DashCaddy localStorage keys to include in backup\n  var BROWSER_STATE_KEYS = [\n    'dashcaddy_site_config', 'dashcaddy_onboarding', 'dashcaddy-encryption-key',\n    'dashcaddy-setup', 'dashcaddy-config',\n    'theme', 'user-themes', 'custom-theme',\n    'custom-apps', 'custom-services', 'toolbar-sections',\n    'weather-location', 'weather-zip', 'weather-geo', 'weather-unit',\n    'clock-style', 'clock-chimes', 'clock-chime-volume'\n  ];\n\n  // Collect all DashCaddy browser state from localStorage\n  function collectBrowserState() {\n    var state = {};\n    // Grab all whitelisted keys\n    for (var i = 0; i < BROWSER_STATE_KEYS.length; i++) {\n      var key = BROWSER_STATE_KEYS[i];\n      var val = safeGet(key);\n      if (val !== null && val !== undefined) state[key] = val;\n    }\n    // Grab dynamic widget-*-enabled keys\n    try {\n      for (var j = 0; j < localStorage.length; j++) {\n        var k = localStorage.key(j);\n        if (/^widget-.+-enabled$/.test(k)) {\n          state[k] = localStorage.getItem(k);\n        }\n      }\n    } catch (e) { /* private browsing */ }\n    return state;\n  }\n\n  // Restore browser state from backup into localStorage\n  function restoreBrowserState(browserState) {\n    if (!browserState || typeof browserState !== 'object') return 0;\n    var count = 0;\n    for (var key in browserState) {\n      if (!browserState.hasOwnProperty(key)) continue;\n      safeSet(key, browserState[key]);\n      count++;\n    }\n    return count;\n  }\n\n  // Handle legacy v1.0.0 import-export format (pre-backup modal)\n  function isLegacyFormat(data) {\n    return data.version && !data.files && data.services;\n  }\n\n  function restoreLegacyFormat(data) {\n    // Map the old flat keys into browserState for localStorage restore\n    var browserState = {};\n    if (data.customServices) browserState['custom-services'] = JSON.stringify(data.customServices);\n    if (data.customApps) browserState['custom-apps'] = JSON.stringify(data.customApps);\n    if (data.weatherZip) browserState['weather-zip'] = data.weatherZip;\n    if (data.theme) browserState['theme'] = data.theme;\n    if (data.userThemes && Object.keys(data.userThemes).length) browserState['user-themes'] = JSON.stringify(data.userThemes);\n    restoreBrowserState(browserState);\n\n    // Push services to server if available\n    if (data.services && Array.isArray(data.services)) {\n      secureFetch('/api/v1/services', {\n        method: 'PUT',\n        headers: { 'Content-Type': 'application/json' },\n        body: JSON.stringify(data.services)\n      }).catch(function() {});\n    }\n\n    // Push themes to server if available\n    if (data.userThemes) {\n      Object.keys(data.userThemes).forEach(function(slug) {\n        var t = data.userThemes[slug];\n        var colors = {};\n        (window.THEME_PROPS || []).forEach(function(p) { if (t[p]) colors[p] = t[p]; });\n        secureFetch('/api/v1/themes/' + slug, {\n          method: 'POST',\n          headers: { 'Content-Type': 'application/json' },\n          body: JSON.stringify({ name: t.name || slug, colors: colors })\n        }).catch(function() {});\n      });\n    }\n  }\n\n  // Inject modal HTML\n  injectModal('backup-modal', `<div id=\"backup-modal\" class=\"weather-modal\">\n    <div class=\"weather-modal-content\" style=\"min-width: 550px; max-width: 650px;\">\n      <h3>\uD83D\uDCBE Backup & Restore</h3>\n      <p class=\"modal-subtitle\">\n        Full backup of your entire DashCaddy setup \u2014 server config, credentials, themes, and browser preferences in one file.\n      </p>\n\n      <!-- Tab bar -->\n      <div class=\"panel-tabs\">\n        <button class=\"panel-tab active\" data-panel=\"backup-manual\">Manual</button>\n        <button class=\"panel-tab\" data-panel=\"backup-schedules-tab\">Schedules</button>\n        <button class=\"panel-tab\" data-panel=\"backup-disk-tab\">Backups on Disk</button>\n        <button class=\"panel-tab\" data-panel=\"backup-pointintime-tab\">Point-in-Time</button>\n        <button class=\"panel-tab\" data-panel=\"backup-history-tab\">History</button>\n      </div>\n\n      <!-- Tab: Manual -->\n      <div id=\"backup-manual\" class=\"panel-section active\">\n        <!-- Export Section -->\n        <div style=\"margin-bottom: 20px; padding: 16px; background: linear-gradient(135deg, color-mix(in srgb, #27ae60 15%, transparent), color-mix(in srgb, #2ecc71 10%, transparent)); border-radius: 10px; border: 1px solid #27ae60;\">\n          <h4 style=\"margin: 0 0 8px; color: #2ecc71; font-size: 0.95rem;\">\uD83D\uDCE4 Export Backup</h4>\n          <p style=\"font-size: 0.8rem; color: var(--muted); margin: 0 0 12px;\">\n            Downloads everything \u2014 services, Caddyfile, credentials, encryption key, themes, and all browser preferences.\n          </p>\n          <button id=\"backup-export-btn\" style=\"width: 100%; padding: 10px; background: linear-gradient(135deg, #27ae60 0%, #2ecc71 100%); border: none; color: white; font-weight: 600; border-radius: 8px; cursor: pointer;\">\n            \u2B07\uFE0F Download Full Backup\n          </button>\n        </div>\n\n        <!-- Import Section -->\n        <div style=\"padding: 16px; background: linear-gradient(135deg, color-mix(in srgb, #3498db 15%, transparent), color-mix(in srgb, #2980b9 10%, transparent)); border-radius: 10px; border: 1px solid #3498db;\">\n          <h4 style=\"margin: 0 0 8px; color: #3498db; font-size: 0.95rem;\">\uD83D\uDCE5 Restore Backup</h4>\n          <p style=\"font-size: 0.8rem; color: var(--muted); margin: 0 0 12px;\">\n            Upload a backup file to restore your entire configuration \u2014 drag and drop ready.\n          </p>\n          <input type=\"file\" id=\"backup-file-input\" accept=\".json\" style=\"display: none;\" />\n          <button id=\"backup-select-file\" style=\"width: 100%; padding: 10px; background: linear-gradient(135deg, #3498db 0%, #2980b9 100%); border: none; color: white; font-weight: 600; border-radius: 8px; cursor: pointer;\">\n            \uD83D\uDCC1 Select Backup File\n          </button>\n          <div id=\"backup-file-name\" style=\"display: none; margin-top: 8px; padding: 8px; background: var(--card-base); border-radius: 6px; font-size: 0.85rem;\"></div>\n        </div>\n\n        <!-- Preview Section (shown after file selected) -->\n        <div id=\"backup-preview\" style=\"display: none; margin-top: 16px; padding: 16px; background: var(--card-base); border-radius: 10px; border: 1px solid var(--border);\">\n          <h4 style=\"margin: 0 0 12px; font-size: 0.9rem;\">\uD83D\uDCCB Backup Contents</h4>\n          <div id=\"backup-preview-content\" style=\"font-size: 0.85rem;\"></div>\n          <div style=\"margin-top: 12px; padding-top: 12px; border-top: 1px solid var(--border);\">\n            <label class=\"checkbox-label\" style=\"font-size: 0.85rem;\">\n              <input type=\"checkbox\" id=\"backup-reload-caddy\" checked />\n              Reload Caddy after restore\n            </label>\n          </div>\n          <button id=\"backup-do-restore-btn\" style=\"width: 100%; margin-top: 12px; padding: 10px; background: linear-gradient(135deg, #e74c3c 0%, #c0392b 100%); border: none; color: white; font-weight: 600; border-radius: 8px; cursor: pointer;\">\n            \u26A1 Restore Everything\n          </button>\n        </div>\n\n        <!-- Result Message -->\n        <div id=\"backup-result\" style=\"display: none; margin-top: 16px; padding: 12px; border-radius: 8px;\"></div>\n      </div>\n\n      <!-- Tab: Schedules (Premium) -->\n      <div id=\"backup-schedules-tab\" class=\"panel-section\">\n        <div id=\"backup-schedules-container\">\n          <div class=\"panel-empty\">\n            <span class=\"empty-icon\">\u23F0</span>\n            <span class=\"brand-spinner\"></span> Loading schedules...\n          </div>\n        </div>\n      </div>\n\n      <!-- Tab: Backups on Disk -->\n      <div id=\"backup-disk-tab\" class=\"panel-section\">\n        <div id=\"backup-disk-container\">\n          <div class=\"panel-empty\">\n            <span class=\"empty-icon\">\uD83D\uDCBE</span>\n            <span class=\"brand-spinner\"></span> Loading backup files...\n          </div>\n        </div>\n      </div>\n\n      <!-- Tab: Point-in-Time Restore -->\n      <div id=\"backup-pointintime-tab\" class=\"panel-section\">\n        <div id=\"pointintime-container\">\n          <div class=\"panel-empty\">\n            <span class=\"empty-icon\">\u23EA</span>\n            <span class=\"brand-spinner\"></span> Loading...\n          </div>\n        </div>\n      </div>\n\n      <!-- Tab: Backup History -->\n      <div id=\"backup-history-tab\" class=\"panel-section\">\n        <div id=\"backup-history-container\" style=\"max-height: 400px; overflow-y: auto;\">\n          <div class=\"panel-empty\">\n            <span class=\"empty-icon\">\uD83D\uDCCB</span>\n            <span class=\"brand-spinner\"></span> Loading backup history...\n          </div>\n        </div>\n      </div>\n\n      <!-- Close Button -->\n      <div class=\"weather-modal-buttons modal-footer-bar\">\n        <button id=\"backup-cancel\">Close</button>\n      </div>\n    </div>\n  </div>`);\n\n  var modal = document.getElementById('backup-modal');\n  var openBtn = document.getElementById('backup-restore-btn');\n  var cancelBtn = document.getElementById('backup-cancel');\n  var exportBtn = document.getElementById('backup-export-btn');\n  var selectFileBtn = document.getElementById('backup-select-file');\n  var fileInput = document.getElementById('backup-file-input');\n  var fileNameDiv = document.getElementById('backup-file-name');\n  var previewDiv = document.getElementById('backup-preview');\n  var previewContent = document.getElementById('backup-preview-content');\n  var restoreBtn = document.getElementById('backup-do-restore-btn');\n  var resultDiv = document.getElementById('backup-result');\n  var scheduleContainer = document.getElementById('backup-schedules-container');\n  var historyContainer = document.getElementById('backup-history-container');\n  var diskContainer = document.getElementById('backup-disk-container');\n  var pointintimeContainer = document.getElementById('pointintime-container');\n\n  var selectedBackup = null;\n\n  // Open modal\n  openBtn?.addEventListener('click', function() {\n    modal.classList.add('show');\n    if (resultDiv) resultDiv.style.display = 'none';\n    if (previewDiv) previewDiv.style.display = 'none';\n    if (fileNameDiv) fileNameDiv.style.display = 'none';\n    selectedBackup = null;\n  });\n\n  wireModal(modal, cancelBtn);\n\n  // === EXPORT: Server backup + browser state in one file ===\n  exportBtn?.addEventListener('click', async function() {\n    exportBtn.disabled = true;\n    exportBtn.innerHTML = '<span class=\"brand-spinner\"></span> Exporting...';\n    try {\n      // Fetch server-side backup (config, services, caddyfile, credentials, encryption key, themes, etc.)\n      var response = await fetch('/api/v1/backup/export');\n      var data = await response.json();\n\n      // Add all browser localStorage state\n      data.browserState = collectBrowserState();\n\n      // Download unified backup\n      var blob = new Blob([JSON.stringify(data, null, 2)], { type: 'application/json' });\n      var url = URL.createObjectURL(blob);\n      var a = document.createElement('a');\n      a.href = url;\n      a.download = 'dashcaddy-backup-' + new Date().toISOString().split('T')[0] + '.json';\n      document.body.appendChild(a);\n      a.click();\n      document.body.removeChild(a);\n      URL.revokeObjectURL(url);\n\n      var stateCount = Object.keys(data.browserState).length;\n      var themeCount = data.themes ? Object.keys(data.themes).length : 0;\n      resultDiv.innerHTML = '\u2705 Full backup downloaded \u2014 server config + ' + stateCount + ' browser settings' + (themeCount ? ' + ' + themeCount + ' themes' : '');\n      resultDiv.style.display = 'block';\n      resultDiv.style.background = 'color-mix(in srgb, var(--ok-fg) 15%, transparent)';\n      resultDiv.style.border = '1px solid var(--ok-fg)';\n    } catch (e) {\n      resultDiv.innerHTML = '\u274C Export failed: ' + escapeHtml(e.message);\n      resultDiv.style.display = 'block';\n      resultDiv.style.background = 'color-mix(in srgb, var(--bad-fg) 15%, transparent)';\n      resultDiv.style.border = '1px solid var(--bad-fg)';\n    }\n    exportBtn.disabled = false;\n    exportBtn.innerHTML = '\u2B07\uFE0F Download Full Backup';\n  });\n\n  // Select file button\n  selectFileBtn?.addEventListener('click', function() { fileInput.click(); });\n\n  // === FILE SELECTED: Preview contents ===\n  fileInput?.addEventListener('change', async function(e) {\n    var file = e.target.files[0];\n    if (!file) return;\n    fileNameDiv.textContent = '\uD83D\uDCC4 ' + file.name;\n    fileNameDiv.style.display = 'block';\n    resultDiv.style.display = 'none';\n    try {\n      var text = await file.text();\n      var backup = JSON.parse(text);\n\n      // Handle legacy v1.0.0 format (from old import-export.js)\n      if (isLegacyFormat(backup)) {\n        selectedBackup = backup;\n        var html = '<div style=\"margin-bottom: 8px; color: var(--muted); font-size: 0.8rem;\">Legacy format (v' + escapeHtml(backup.version) + ')</div>';\n        html += '<div style=\"display: flex; flex-wrap: wrap; gap: 6px;\">';\n        if (backup.services?.length) html += '<span style=\"padding: 4px 8px; background: var(--base); border-radius: 4px; font-size: 0.8rem;\">\uD83D\uDCCB ' + backup.services.length + ' services</span>';\n        if (backup.customApps?.length) html += '<span style=\"padding: 4px 8px; background: var(--base); border-radius: 4px; font-size: 0.8rem;\">\uD83D\uDCE6 ' + backup.customApps.length + ' custom apps</span>';\n        if (backup.theme) html += '<span style=\"padding: 4px 8px; background: var(--base); border-radius: 4px; font-size: 0.8rem;\">\uD83C\uDFA8 Theme: ' + escapeHtml(backup.theme) + '</span>';\n        if (backup.userThemes) html += '<span style=\"padding: 4px 8px; background: var(--base); border-radius: 4px; font-size: 0.8rem;\">\uD83C\uDFA8 ' + Object.keys(backup.userThemes).length + ' custom themes</span>';\n        html += '</div>';\n        previewContent.innerHTML = html;\n        previewDiv.style.display = 'block';\n        return;\n      }\n\n      // v1.1+ / v2.0 format \u2014 send to server for preview\n      var response = await secureFetch('/api/v1/backup/preview', {\n        method: 'POST',\n        headers: { 'Content-Type': 'application/json' },\n        body: JSON.stringify(backup)\n      });\n      var preview = await response.json();\n      if (preview.success) {\n        selectedBackup = backup;\n        var html = '<div style=\"margin-bottom: 8px; color: var(--muted); font-size: 0.8rem;\">Exported: ' + new Date(backup.exportedAt).toLocaleString() + ' (v' + escapeHtml(backup.version) + ')</div>';\n\n        // Server files\n        html += '<div style=\"margin-bottom: 6px; font-size: 0.75rem; color: var(--muted); text-transform: uppercase; letter-spacing: 0.5px;\">Server Config</div>';\n        html += '<div style=\"display: flex; flex-wrap: wrap; gap: 6px; margin-bottom: 10px;\">';\n        for (var key in preview.preview.files) {\n          var info = preview.preview.files[key];\n          var icon = info.action === 'create' ? '\uD83C\uDD95' : '\uD83D\uDCDD';\n          html += '<span style=\"padding: 4px 8px; background: var(--base); border-radius: 4px; font-size: 0.8rem;\">' + icon + ' ' + escapeHtml(info.description) + '</span>';\n        }\n        html += '</div>';\n\n        // Services count\n        if (preview.preview.serviceCount) {\n          html += '<div style=\"font-size: 0.8rem; color: var(--accent); margin-bottom: 6px;\">' + preview.preview.serviceCount + ' services</div>';\n        }\n\n        // Themes\n        if (preview.preview.themeCount) {\n          html += '<div style=\"font-size: 0.8rem; color: var(--accent); margin-bottom: 6px;\">\uD83C\uDFA8 ' + preview.preview.themeCount + ' custom themes</div>';\n        }\n\n        // Browser state\n        if (preview.preview.browserStateCount) {\n          html += '<div style=\"margin-top: 6px; font-size: 0.75rem; color: var(--muted); text-transform: uppercase; letter-spacing: 0.5px;\">Browser Preferences</div>';\n          html += '<div style=\"font-size: 0.8rem; color: var(--accent);\">\uD83D\uDDA5\uFE0F ' + preview.preview.browserStateCount + ' saved settings (theme, weather, clock, widgets, etc.)</div>';\n        }\n\n        previewContent.innerHTML = html;\n        previewDiv.style.display = 'block';\n      } else {\n        resultDiv.innerHTML = '\u26A0\uFE0F Invalid backup file: ' + escapeHtml(preview.error);\n        resultDiv.style.display = 'block';\n        resultDiv.style.background = 'color-mix(in srgb, #f39c12 15%, transparent)';\n        resultDiv.style.border = '1px solid #f39c12';\n        previewDiv.style.display = 'none';\n      }\n    } catch (e) {\n      resultDiv.innerHTML = '\u274C Could not read file: ' + escapeHtml(e.message);\n      resultDiv.style.display = 'block';\n      resultDiv.style.background = 'color-mix(in srgb, var(--bad-fg) 15%, transparent)';\n      resultDiv.style.border = '1px solid var(--bad-fg)';\n      previewDiv.style.display = 'none';\n    }\n  });\n\n  // === RESTORE: Server + browser state ===\n  restoreBtn?.addEventListener('click', async function() {\n    if (!selectedBackup) return;\n    if (!confirm('This will overwrite your current configuration and browser preferences. Continue?')) return;\n    restoreBtn.disabled = true;\n    restoreBtn.innerHTML = '<span class=\"brand-spinner\"></span> Restoring...';\n    try {\n      // Handle legacy format\n      if (isLegacyFormat(selectedBackup)) {\n        restoreLegacyFormat(selectedBackup);\n        resultDiv.innerHTML = '\u2705 Legacy backup restored \u2014 browser settings and services imported.';\n        resultDiv.style.background = 'color-mix(in srgb, var(--ok-fg) 15%, transparent)';\n        resultDiv.style.border = '1px solid var(--ok-fg)';\n        resultDiv.style.display = 'block';\n        setTimeout(function() { location.reload(); }, 2000);\n        restoreBtn.disabled = false;\n        restoreBtn.innerHTML = '\u26A1 Restore Everything';\n        return;\n      }\n\n      // v1.1+ / v2.0 \u2014 restore server-side first\n      var reloadCaddy = document.getElementById('backup-reload-caddy')?.checked ?? true;\n      var response = await secureFetch('/api/v1/backup/restore', {\n        method: 'POST',\n        headers: { 'Content-Type': 'application/json' },\n        body: JSON.stringify({ backup: selectedBackup, options: { reloadCaddy: reloadCaddy } })\n      });\n      var data = await response.json();\n\n      // Then restore browser state\n      var browserCount = 0;\n      if (selectedBackup.browserState) {\n        browserCount = restoreBrowserState(selectedBackup.browserState);\n      }\n\n      if (data.success) {\n        var msg = '\u2705 ' + data.message;\n        if (browserCount > 0) msg += '<br><small style=\"color: var(--muted);\">' + browserCount + ' browser settings restored</small>';\n        if (data.results.caddyReloaded) msg += '<br><small style=\"color: var(--muted);\">Caddy configuration reloaded</small>';\n        resultDiv.innerHTML = msg;\n        resultDiv.style.background = 'color-mix(in srgb, var(--ok-fg) 15%, transparent)';\n        resultDiv.style.border = '1px solid var(--ok-fg)';\n        setTimeout(function() { location.reload(); }, 2000);\n      } else {\n        resultDiv.innerHTML = '\u26A0\uFE0F ' + escapeHtml(data.message);\n        if (browserCount > 0) resultDiv.innerHTML += '<br><small style=\"color: var(--muted);\">' + browserCount + ' browser settings were restored</small>';\n        if (data.results?.errors?.length > 0) {\n          resultDiv.innerHTML += '<br><small>' + data.results.errors.map(function(e) { return escapeHtml(e.file) + ': ' + escapeHtml(e.error); }).join(', ') + '</small>';\n        }\n        resultDiv.style.background = 'color-mix(in srgb, #f39c12 15%, transparent)';\n        resultDiv.style.border = '1px solid #f39c12';\n      }\n      resultDiv.style.display = 'block';\n    } catch (e) {\n      resultDiv.innerHTML = '\u274C Restore failed: ' + escapeHtml(e.message);\n      resultDiv.style.display = 'block';\n      resultDiv.style.background = 'color-mix(in srgb, var(--bad-fg) 15%, transparent)';\n      resultDiv.style.border = '1px solid var(--bad-fg)';\n    }\n    restoreBtn.disabled = false;\n    restoreBtn.innerHTML = '\u26A1 Restore Everything';\n  });\n\n  // === Schedules Tab (Premium) ===\n  async function loadSchedulesTab() {\n    if (!scheduleContainer) return;\n    scheduleContainer.innerHTML = '<div class=\"panel-empty\"><span class=\"brand-spinner\"></span> Loading...</div>';\n    try {\n      var res = await fetch('/api/v1/backups/schedule');\n      var data = await res.json();\n      \n      if (data.premiumRequired) {\n        scheduleContainer.innerHTML = '<div class=\"panel-empty\" style=\"padding: 24px; text-align: center;\">' +\n          '<div style=\"font-size: 2rem; margin-bottom: 12px;\">\u2B50</div>' +\n          '<div style=\"font-weight: 600; margin-bottom: 8px;\">Premium Feature</div>' +\n          '<div style=\"font-size: 0.85rem; color: var(--muted);\">Auto-backup scheduling requires a DashCaddy Premium subscription.</div>' +\n          '<button onclick=\"showNotification(\\'Upgrade to Premium to enable auto-backups!\\', \\'info\\'); scrollToSection(\\'license\\');\" style=\"margin-top: 16px; padding: 8px 20px; background: linear-gradient(135deg, #f39c12, #e67e22); border: none; color: white; border-radius: 8px; cursor: pointer; font-weight: 600;\">Upgrade to Premium</button>' +\n          '</div>';\n        return;\n      }\n      \n      if (!data.success) throw new Error(data.error || 'Failed to load schedules');\n      \n      var schedules = data.schedules || [];\n      \n      if (schedules.length === 0) {\n        scheduleContainer.innerHTML = '<div class=\"panel-empty\">' +\n          '<span class=\"empty-icon\">\u23F0</span>' +\n          '<div>No backup schedules configured</div>' +\n          '<div style=\"font-size: 0.8rem; color: var(--muted); margin-top: 4px;\">Select apps below to enable auto-backup</div>' +\n          '</div>';\n        return;\n      }\n      \n      var html = '<div style=\"display: flex; flex-direction: column; gap: 8px;\">';\n      for (var i = 0; i < schedules.length; i++) {\n        var sch = schedules[i];\n        var nextRunStr = sch.nextRun ? new Date(sch.nextRun).toLocaleString() : 'Not scheduled';\n        var lastRunStr = sch.lastRun ? new Date(sch.lastRun).toLocaleString() : 'Never';\n        \n        html += '<div style=\"padding: 12px 14px; background: var(--card-base); border-radius: 8px; border: 1px solid var(--border);\">' +\n          '<div style=\"display: flex; justify-content: space-between; align-items: center; margin-bottom: 8px;\">' +\n          '  <div style=\"font-weight: 600; font-size: 0.9rem;\">' + escapeHtml(sch.appId) + '</div>' +\n          '  <label class=\"toggle-switch\" style=\"display: flex; align-items: center; gap: 6px;\">' +\n          '    <input type=\"checkbox\" class=\"schedule-toggle\" data-appid=\"' + escapeHtml(sch.appId) + '\"' + (sch.enabled ? ' checked' : '') + ' />' +\n          '    <span style=\"font-size: 0.75rem; color: var(--muted);\">' + (sch.enabled ? 'ON' : 'OFF') + '</span>' +\n          '  </label>' +\n          '</div>' +\n          '<div style=\"display: grid; grid-template-columns: 1fr 1fr; gap: 8px; font-size: 0.8rem; margin-bottom: 10px;\">' +\n          '  <div><span style=\"color: var(--muted);\">Schedule:</span> <select class=\"schedule-select\" data-appid=\"' + escapeHtml(sch.appId) + '\" style=\"background: var(--base); border: 1px solid var(--border); border-radius: 4px; padding: 2px 6px;\">' +\n          '    <option value=\"hourly\"' + (sch.schedule === 'hourly' ? ' selected' : '') + '>Hourly</option>' +\n          '    <option value=\"daily\"' + (sch.schedule === 'daily' ? ' selected' : '') + '>Daily</option>' +\n          '    <option value=\"weekly\"' + (sch.schedule === 'weekly' ? ' selected' : '') + '>Weekly</option>' +\n          '    <option value=\"monthly\"' + (sch.schedule === 'monthly' ? ' selected' : '') + '>Monthly</option>' +\n          '  </select></div>' +\n          '  <div><span style=\"color: var(--muted);\">Keep last:</span> <input type=\"number\" class=\"retention-input\" data-appid=\"' + escapeHtml(sch.appId) + '\" value=\"' + (sch.retention?.keep || 7) + '\" min=\"1\" max=\"100\" style=\"width: 50px; background: var(--base); border: 1px solid var(--border); border-radius: 4px; padding: 2px 6px;\" /></div>' +\n          '</div>' +\n          '<div style=\"font-size: 0.75rem; color: var(--muted); margin-bottom: 10px;\">' +\n          '  <div>Next run: ' + escapeHtml(nextRunStr) + '</div>' +\n          '  <div>Last run: ' + escapeHtml(lastRunStr) + '</div>' +\n          '</div>' +\n          '<div style=\"display: flex; gap: 6px;\">' +\n          '  <button class=\"schedule-run-now\" data-appid=\"' + escapeHtml(sch.appId) + '\" style=\"padding: 5px 12px; font-size: 0.8rem; background: color-mix(in srgb, var(--ok-fg) 20%, transparent); border: 1px solid var(--ok-fg); color: var(--ok-fg); border-radius: 6px; cursor: pointer;\">\u25B6\uFE0F Run Now</button>' +\n          '  <button class=\"schedule-delete\" data-appid=\"' + escapeHtml(sch.appId) + '\" style=\"padding: 5px 12px; font-size: 0.8rem; background: transparent; border: 1px solid var(--bad-fg); color: var(--bad-fg); border-radius: 6px; cursor: pointer;\">\uD83D\uDDD1\uFE0F Remove</button>' +\n          '</div>' +\n          '</div>';\n      }\n      html += '</div>';\n      \n      // Add \"Add Schedule\" section at bottom\n      html += '<div style=\"margin-top: 16px; padding: 16px; background: color-mix(in srgb, var(--accent) 5%, transparent); border-radius: 10px; border: 1px dashed var(--border);\">' +\n        '<h4 style=\"margin: 0 0 12px; font-size: 0.85rem; color: var(--muted);\">\u2795 Add New Schedule</h4>' +\n        '<div style=\"display: flex; gap: 8px; flex-wrap: wrap;\">' +\n        '  <input type=\"text\" id=\"new-schedule-appid\" placeholder=\"App ID (e.g., plex, sonarr)\" style=\"flex: 1; min-width: 150px; padding: 8px; border-radius: 6px; border: 1px solid var(--border); background: var(--base);\" />' +\n        '  <select id=\"new-schedule-interval\" style=\"padding: 8px; border-radius: 6px; border: 1px solid var(--border); background: var(--base);\">' +\n        '    <option value=\"hourly\">Hourly</option>' +\n        '    <option value=\"daily\" selected>Daily</option>' +\n        '    <option value=\"weekly\">Weekly</option>' +\n        '    <option value=\"monthly\">Monthly</option>' +\n        '    <option value=\"6h\">Every 6 hours</option>' +\n        '    <option value=\"30m\">Every 30 minutes</option>' +\n        '  </select>' +\n        '  <input type=\"number\" id=\"new-schedule-retention\" value=\"7\" min=\"1\" max=\"100\" placeholder=\"Keep\" style=\"width: 70px; padding: 8px; border-radius: 6px; border: 1px solid var(--border); background: var(--base);\" />' +\n        '  <button id=\"add-schedule-btn\" style=\"padding: 8px 16px; background: var(--accent); border: none; color: white; border-radius: 6px; cursor: pointer; font-weight: 500;\">Add Schedule</button>' +\n        '</div>' +\n        '</div>';\n      \n      scheduleContainer.innerHTML = html;\n      \n      // Wire up event listeners\n      scheduleContainer.querySelectorAll('.schedule-toggle').forEach(function(toggle) {\n        toggle.addEventListener('change', function() { updateSchedule(toggle.dataset.appid, { enabled: toggle.checked }); });\n      });\n      scheduleContainer.querySelectorAll('.schedule-select').forEach(function(sel) {\n        sel.addEventListener('change', function() { updateSchedule(sel.dataset.appid, { schedule: sel.value }); });\n      });\n      scheduleContainer.querySelectorAll('.retention-input').forEach(function(inp) {\n        inp.addEventListener('change', function() { updateSchedule(inp.dataset.appid, { retention: { keep: parseInt(inp.value) || 7 } }); });\n      });\n      scheduleContainer.querySelectorAll('.schedule-run-now').forEach(function(btn) {\n        btn.addEventListener('click', function() { runBackupNow(btn.dataset.appid); });\n      });\n      scheduleContainer.querySelectorAll('.schedule-delete').forEach(function(btn) {\n        btn.addEventListener('click', function() { deleteSchedule(btn.dataset.appid); });\n      });\n      document.getElementById('add-schedule-btn')?.addEventListener('click', addNewSchedule);\n      \n    } catch (e) {\n      scheduleContainer.innerHTML = '<div class=\"panel-empty\" style=\"color: var(--bad-fg);\">Failed to load: ' + escapeHtml(e.message) + '</div>';\n    }\n  }\n  \n  async function updateSchedule(appId, updates) {\n    try {\n      var res = await secureFetch('/api/v1/backups/schedule', {\n        method: 'POST',\n        headers: { 'Content-Type': 'application/json' },\n        body: JSON.stringify({ appId, ...updates })\n      });\n      var data = await res.json();\n      if (data.success) {\n        showNotification('Schedule updated for ' + appId, 'success');\n      } else {\n        showNotification('Update failed: ' + (data.error || 'Unknown'), 'error');\n        loadSchedulesTab(); // Refresh on failure\n      }\n    } catch (e) {\n      showNotification('Error: ' + e.message, 'error');\n    }\n  }\n  \n  async function runBackupNow(appId) {\n    try {\n      var res = await secureFetch('/api/v1/backups/backup/' + encodeURIComponent(appId), {\n        method: 'POST',\n        headers: { 'Content-Type': 'application/json' }\n      });\n      var data = await res.json();\n      if (data.success) {\n        showNotification('Backup started for ' + appId + '!', 'success');\n      } else {\n        showNotification('Backup failed: ' + (data.error || 'Unknown'), 'error');\n      }\n    } catch (e) {\n      showNotification('Error: ' + e.message, 'error');\n    }\n  }\n  \n  async function deleteSchedule(appId) {\n    if (!confirm('Remove backup schedule for ' + appId + '?')) return;\n    try {\n      var res = await secureFetch('/api/v1/backups/schedule/' + encodeURIComponent(appId), { method: 'DELETE' });\n      var data = await res.json();\n      if (data.success) {\n        showNotification('Schedule removed for ' + appId, 'success');\n        loadSchedulesTab();\n      } else {\n        showNotification('Delete failed: ' + (data.error || 'Unknown'), 'error');\n      }\n    } catch (e) {\n      showNotification('Error: ' + e.message, 'error');\n    }\n  }\n  \n  async function addNewSchedule() {\n    var appId = document.getElementById('new-schedule-appid')?.value?.trim();\n    var interval = document.getElementById('new-schedule-interval')?.value || 'daily';\n    var retention = parseInt(document.getElementById('new-schedule-retention')?.value) || 7;\n    \n    if (!appId) {\n      showNotification('Please enter an App ID', 'warning');\n      return;\n    }\n    \n    try {\n      var res = await secureFetch('/api/v1/backups/schedule', {\n        method: 'POST',\n        headers: { 'Content-Type': 'application/json' },\n        body: JSON.stringify({ appId, schedule: interval, retention: { keep: retention }, enabled: true })\n      });\n      var data = await res.json();\n      if (data.success) {\n        showNotification('Schedule created for ' + appId, 'success');\n        loadSchedulesTab();\n        // Clear inputs\n        var appIdInput = document.getElementById('new-schedule-appid');\n        if (appIdInput) appIdInput.value = '';\n      } else {\n        showNotification('Failed: ' + (data.error || 'Unknown'), 'error');\n      }\n    } catch (e) {\n      showNotification('Error: ' + e.message, 'error');\n    }\n  }\n  \n  // === Backups on Disk Tab ===\n  async function loadDiskBackups() {\n    if (!diskContainer) return;\n    diskContainer.innerHTML = '<div class=\"panel-empty\"><span class=\"brand-spinner\"></span> Loading...</div>';\n    try {\n      var res = await fetch('/api/v1/backups/files');\n      var data = await res.json();\n      if (!data.success) throw new Error(data.error || 'Failed to load');\n\n      var files = data.files || [];\n\n      if (files.length === 0) {\n        diskContainer.innerHTML = '<div class=\"panel-empty\">' +\n          '<span class=\"empty-icon\">\uD83D\uDCBE</span>' +\n          '<div>No backup files on disk</div>' +\n          '<div style=\"font-size: 0.8rem; color: var(--muted); margin-top: 4px;\">Run a backup to create backup files</div>' +\n          '</div>';\n        return;\n      }\n\n      // Group by appId\n      var byApp = {};\n      for (var i = 0; i < files.length; i++) {\n        var f = files[i];\n        var appId = f.appId || 'unknown';\n        if (!byApp[appId]) byApp[appId] = [];\n        byApp[appId].push(f);\n      }\n\n      var html = '<div style=\"font-size: 0.75rem; color: var(--muted); margin-bottom: 12px;\">' + files.length + ' backup file(s) across ' + Object.keys(byApp).length + ' app(s)</div>';\n      html += '<div style=\"display: flex; flex-direction: column; gap: 12px;\">';\n\n      var appIds = Object.keys(byApp).sort();\n      for (var a = 0; a < appIds.length; a++) {\n        var appId = appIds[a];\n        var appFiles = byApp[appId];\n        html += '<div style=\"background: var(--card-base); border-radius: 8px; border: 1px solid var(--border); overflow: hidden;\">' +\n          '<div style=\"padding: 8px 12px; background: color-mix(in srgb, var(--accent) 8%, transparent); border-bottom: 1px solid var(--border); font-weight: 600; font-size: 0.85rem;\">' +\n          escapeHtml(appId) + ' <span style=\"font-weight: normal; color: var(--muted); font-size: 0.75rem;\">(' + appFiles.length + ' backup(s))</span>' +\n          '</div>';\n\n        for (var j = 0; j < appFiles.length; j++) {\n          var f = appFiles[j];\n          var dateStr = new Date(f.timestamp).toLocaleString();\n          html += '<div style=\"padding: 10px 12px; border-bottom: 1px solid var(--border);\">' +\n            '<div style=\"display: flex; justify-content: space-between; align-items: center; margin-bottom: 4px;\">' +\n            '  <div style=\"font-weight: 500; font-size: 0.85rem;\">' + escapeHtml(f.name) + '</div>' +\n            '  <div style=\"font-size: 0.75rem; color: var(--muted);\">' + f.sizeFormatted + '</div>' +\n            '</div>' +\n            '<div style=\"font-size: 0.75rem; color: var(--muted); margin-bottom: 8px;\">' + dateStr + '</div>' +\n            '<div style=\"display: flex; gap: 6px;\">' +\n            '  <button class=\"disk-compare-btn\" data-appid=\"' + escapeHtml(appId) + '\" data-filename=\"' + escapeHtml(f.name) + '\" style=\"padding: 3px 8px; font-size: 0.75rem; background: transparent; border: 1px solid var(--accent); color: var(--accent); border-radius: 5px; cursor: pointer;\">Compare</button>' +\n            '  <button class=\"disk-restore-btn\" data-appid=\"' + escapeHtml(appId) + '\" data-filename=\"' + escapeHtml(f.name) + '\" style=\"padding: 3px 8px; font-size: 0.75rem; background: linear-gradient(135deg, var(--ok-fg), #27ae60); border: none; color: white; border-radius: 5px; cursor: pointer; font-weight: 500;\">Restore</button>' +\n            '</div>' +\n            '</div>';\n        }\n        html += '</div>';\n      }\n      html += '</div>';\n\n      diskContainer.innerHTML = html;\n\n      // Wire up buttons\n      diskContainer.querySelectorAll('.disk-compare-btn').forEach(function(btn) {\n        btn.addEventListener('click', function() { compareBackupFile(btn.dataset.appid, btn.dataset.filename); });\n      });\n      diskContainer.querySelectorAll('.disk-restore-btn').forEach(function(btn) {\n        btn.addEventListener('click', function() { restoreBackupFile(btn.dataset.appid, btn.dataset.filename); });\n      });\n    } catch (e) {\n      diskContainer.innerHTML = '<div class=\"panel-empty\" style=\"color: var(--bad-fg);\">Failed: ' + escapeHtml(e.message) + '</div>';\n    }\n  }\n  \n  // === Backup History Tab ===\n  async function loadBackupHistory() {\n    if (!historyContainer) return;\n    historyContainer.innerHTML = '<div class=\"panel-empty\"><span class=\"brand-spinner\"></span> Loading...</div>';\n    try {\n      var res = await fetch('/api/v1/backups/history?limit=50');\n      var data = await res.json();\n      if (!data.success || !data.history?.length) {\n        historyContainer.innerHTML = '<div class=\"panel-empty\"><span class=\"empty-icon\">\uD83D\uDCCB</span> No backup history yet</div>';\n        return;\n      }\n      var html = '<div style=\"display: flex; flex-direction: column; gap: 6px;\">';\n      for (var i = 0; i < data.history.length; i++) {\n        var bk = data.history[i];\n        var sizeMB = bk.size ? (bk.size / 1024 / 1024).toFixed(2) : '?';\n        html += '<div style=\"padding: 10px 12px; background: var(--card-base); border-radius: 6px; border: 1px solid var(--border); font-size: 0.85rem;\">';\n        html += '  <div style=\"display: flex; justify-content: space-between; align-items: center; margin-bottom: 4px;\">';\n        html += '    <span style=\"font-weight: 500;\">' + escapeHtml(bk.name || 'backup') + '</span>';\n        html += '    <div style=\"display: flex; align-items: center; gap: 8px;\">';\n        html += '      <span class=\"status-badge ' + (bk.status === 'success' ? 'success' : 'down') + '\">' + escapeHtml(bk.status) + '</span>';\n        if (bk.status === 'success') html += '      <button class=\"backup-restore-btn\" data-backup-id=\"' + escapeHtml(bk.id) + '\" style=\"padding: 3px 8px; font-size: 0.75rem;\">Restore</button>';\n        html += '    </div>';\n        html += '  </div>';\n        html += '  <div style=\"font-size: 0.75rem; color: var(--muted);\">';\n        html += '    ' + new Date(bk.timestamp).toLocaleString() + ' | ' + sizeMB + ' MB | ' + (bk.duration ? (bk.duration / 1000).toFixed(1) + 's' : '--');\n        if (bk.encrypted) html += ' | \uD83D\uDD12';\n        html += '  </div>';\n        html += '</div>';\n      }\n      html += '</div>';\n      historyContainer.innerHTML = html;\n      historyContainer.querySelectorAll('.backup-restore-btn').forEach(function(btn) {\n        btn.addEventListener('click', function() { window.__restoreServerBackup(btn.dataset.backupId); });\n      });\n    } catch (e) {\n      historyContainer.innerHTML = '<div class=\"panel-empty\" style=\"color: var(--bad-fg);\">Failed: ' + escapeHtml(e.message) + '</div>';\n    }\n  }\n\n  window.__restoreServerBackup = async function(backupId) {\n    if (!confirm('Restore from this server backup? This will overwrite current configuration.')) return;\n    try {\n      var res = await secureFetch('/api/v1/backups/restore/' + backupId, {\n        method: 'POST',\n        headers: { 'Content-Type': 'application/json' },\n        body: JSON.stringify({ restoreServices: true, restoreConfig: true })\n      });\n      var data = await res.json();\n      if (data.success) {\n        showNotification('Restore completed successfully!', 'success');\n        location.reload();\n      } else {\n        showNotification('Restore failed: ' + (data.error || 'Unknown error'), 'error');\n      }\n    } catch (e) { showNotification('Restore error: ' + e.message, 'error'); }\n  };\n\n  // Lazy-load tabs\n  document.querySelector('[data-panel=\"backup-schedules-tab\"]')?.addEventListener('click', loadSchedulesTab);\n  document.querySelector('[data-panel=\"backup-disk-tab\"]')?.addEventListener('click', loadDiskBackups);\n  document.querySelector('[data-panel=\"backup-pointintime-tab\"]')?.addEventListener('click', loadPointInTimeTab);\n  document.querySelector('[data-panel=\"backup-history-tab\"]')?.addEventListener('click', loadBackupHistory);\n\n  // ===== Point-in-Time Restore Tab =====\n  async function loadPointInTimeTab() {\n    if (!pointintimeContainer) return;\n\n    // Check premium\n    try {\n      var licenseRes = await fetch('/api/v1/license/status');\n      var licenseData = await licenseRes.json();\n      if (licenseData.tier !== 'premium') {\n        pointintimeContainer.innerHTML = '<div class=\"panel-empty\" style=\"padding: 24px; text-align: center;\">' +\n          '<div style=\"font-size: 2rem; margin-bottom: 12px;\">\u2B50</div>' +\n          '<div style=\"font-weight: 600; margin-bottom: 8px;\">Premium Feature</div>' +\n          '<div style=\"font-size: 0.85rem; color: var(--muted);\">Point-in-time restore requires DashCaddy Premium with auto-backup enabled.</div>' +\n          '<button onclick=\"showNotification(\\'Upgrade to Premium for point-in-time restore!\\', \\'info\\'); scrollToSection(\\'license\\');\" style=\"margin-top: 16px; padding: 8px 20px; background: linear-gradient(135deg, #f39c12, #e67e22); border: none; color: white; border-radius: 8px; cursor: pointer; font-weight: 600;\">Upgrade to Premium</button>' +\n          '</div>';\n        return;\n      }\n    } catch (e) { /* ignore */ }\n\n    pointintimeContainer.innerHTML = '<div class=\"panel-empty\"><span class=\"brand-spinner\"></span> Loading...</div>';\n\n    try {\n      // Fetch services for dropdown\n      var servicesRes = await fetch('/api/v1/services');\n      var servicesData = await servicesRes.json();\n      var services = servicesData.services || [];\n\n      if (services.length === 0) {\n        pointintimeContainer.innerHTML = '<div class=\"panel-empty\"><span class=\"empty-icon\">\uD83D\uDCE6</span> No apps deployed yet</div>';\n        return;\n      }\n\n      var html = '<div style=\"padding: 8px 0 12px;\">' +\n        '<div style=\"display: flex; gap: 8px; align-items: center; margin-bottom: 12px;\">' +\n        '  <label style=\"font-size: 0.85rem; color: var(--muted); white-space: nowrap;\">App:</label>' +\n        '  <select id=\"pit-app-select\" style=\"flex: 1; padding: 8px; border-radius: 6px; border: 1px solid var(--border); background: var(--base); max-width: 240px;\">';\n      for (var i = 0; i < services.length; i++) {\n        html += '<option value=\"' + escapeHtml(services[i].id || services[i].name || '') + '\">' +\n          escapeHtml(services[i].name || services[i].id || '') + '</option>';\n      }\n      html += '</select>' +\n        '  <button id=\"pit-load-btn\" style=\"padding: 8px 16px; background: var(--accent); border: none; color: white; border-radius: 6px; cursor: pointer; font-weight: 500;\">Load Backups</button>' +\n        '</div>' +\n        '<div id=\"pit-backups-list\" style=\"max-height: 320px; overflow-y: auto;\"></div>' +\n        '</div>';\n\n      pointintimeContainer.innerHTML = html;\n\n      document.getElementById('pit-load-btn')?.addEventListener('click', function() {\n        var appId = document.getElementById('pit-app-select')?.value;\n        if (appId) loadPointInTimeBackups(appId);\n      });\n    } catch (e) {\n      pointintimeContainer.innerHTML = '<div class=\"panel-empty\" style=\"color: var(--bad-fg);\">Failed: ' + escapeHtml(e.message) + '</div>';\n    }\n  }\n\n  async function loadPointInTimeBackups(appId) {\n    var listEl = document.getElementById('pit-backups-list');\n    if (!listEl) return;\n\n    listEl.innerHTML = '<div style=\"padding: 20px; text-align: center;\"><span class=\"brand-spinner\"></span> Loading backups...</div>';\n\n    try {\n      var res = await fetch('/api/v1/backups/files/' + encodeURIComponent(appId));\n      var data = await res.json();\n\n      if (!data.success || !data.files || data.files.length === 0) {\n        listEl.innerHTML = '<div class=\"panel-empty\"><span class=\"empty-icon\">\uD83D\uDCBE</span> No backup files for ' + escapeHtml(appId) + '</div>';\n        return;\n      }\n\n      var html = '<div style=\"font-size: 0.75rem; color: var(--muted); margin-bottom: 8px;\">' + data.files.length + ' backup(s)</div>' +\n        '<div style=\"display: flex; flex-direction: column; gap: 6px;\">';\n\n      for (var i = 0; i < data.files.length; i++) {\n        var f = data.files[i];\n        var dateStr = new Date(f.timestamp).toLocaleString();\n        html += '<div style=\"padding: 10px 12px; background: var(--card-base); border-radius: 8px; border: 1px solid var(--border);\">' +\n          '<div style=\"display: flex; justify-content: space-between; align-items: center; margin-bottom: 4px;\">' +\n          '  <div style=\"font-weight: 500; font-size: 0.85rem;\">' + escapeHtml(f.name) + '</div>' +\n          '  <div style=\"font-size: 0.75rem; color: var(--muted);\">' + f.sizeFormatted + '</div>' +\n          '</div>' +\n          '<div style=\"font-size: 0.75rem; color: var(--muted); margin-bottom: 8px;\">' + dateStr + '</div>' +\n          '<div style=\"display: flex; gap: 6px;\">' +\n          '  <button class=\"pit-compare-btn\" data-appid=\"' + escapeHtml(appId) + '\" data-filename=\"' + escapeHtml(f.name) + '\" style=\"padding: 4px 10px; font-size: 0.75rem; background: transparent; border: 1px solid var(--accent); color: var(--accent); border-radius: 5px; cursor: pointer;\">Compare</button>' +\n          '  <button class=\"pit-restore-btn\" data-appid=\"' + escapeHtml(appId) + '\" data-filename=\"' + escapeHtml(f.name) + '\" style=\"padding: 4px 10px; font-size: 0.75rem; background: linear-gradient(135deg, var(--ok-fg), #27ae60); border: none; color: white; border-radius: 5px; cursor: pointer; font-weight: 500;\">Restore</button>' +\n          '</div>' +\n          '</div>';\n      }\n      html += '</div>';\n      listEl.innerHTML = html;\n\n      // Wire up buttons\n      listEl.querySelectorAll('.pit-compare-btn').forEach(function(btn) {\n        btn.addEventListener('click', function() { compareBackupFile(btn.dataset.appid, btn.dataset.filename); });\n      });\n      listEl.querySelectorAll('.pit-restore-btn').forEach(function(btn) {\n        btn.addEventListener('click', function() { restoreBackupFile(btn.dataset.appid, btn.dataset.filename); });\n      });\n    } catch (e) {\n      listEl.innerHTML = '<div class=\"panel-empty\" style=\"color: var(--bad-fg);\">Failed: ' + escapeHtml(e.message) + '</div>';\n    }\n  }\n\n  async function compareBackupFile(appId, filename) {\n    try {\n      var res = await secureFetch('/api/v1/backups/compare/' + encodeURIComponent(filename), {\n        method: 'POST',\n        headers: { 'Content-Type': 'application/json' },\n        body: JSON.stringify({})\n      });\n      var data = await res.json();\n      if (!data.success) {\n        showNotification('Compare failed: ' + (data.error || 'Unknown'), 'error');\n        return;\n      }\n\n      var diff = data.diff;\n      var html = '<div style=\"position: fixed; top: 0; left: 0; right: 0; bottom: 0; background: rgba(0,0,0,0.5); z-index: 10000; display: flex; align-items: center; justify-content: center;\" id=\"compare-overlay\">' +\n        '<div style=\"background: var(--base); border-radius: 12px; max-width: 600px; width: 90%; max-height: 80vh; overflow: auto; padding: 20px; border: 1px solid var(--border);\">' +\n        '<h4 style=\"margin: 0 0 16px;\">\uD83D\uDCCA Compare: ' + escapeHtml(filename) + '</h4>' +\n        '<div style=\"font-size: 0.8rem; color: var(--muted); margin-bottom: 16px;\">Size: ' + (diff.sizeFormatted || '?') + ' | Created: ' + new Date(diff.timestamp).toLocaleString() + '</div>';\n\n      if (diff.services) {\n        var svcChanged = diff.services.hasChanges ? '\uD83D\uDD34' : '\uD83D\uDFE2';\n        html += '<div style=\"margin-bottom: 12px; padding: 10px; background: var(--card-base); border-radius: 6px; border: 1px solid var(--border);\">' +\n          '<div style=\"font-weight: 600; font-size: 0.85rem; margin-bottom: 4px;\">' + svcChanged + ' Services (backup vs current)</div>' +\n          '<div style=\"font-size: 0.8rem; color: var(--muted);\">Backup: ' + diff.services.backupCount + ' services | Current: ' + diff.services.currentCount + ' services</div>';\n        if (diff.services.hasChanges) {\n          html += '<div style=\"margin-top: 6px; font-size: 0.8rem; color: #f39c12;\">Services differ \u2014 restoring will replace current configuration</div>';\n        }\n        html += '</div>';\n      }\n\n      if (diff.config) {\n        var cfgChanged = diff.config.hasChanges ? '\uD83D\uDD34' : '\uD83D\uDFE2';\n        html += '<div style=\"margin-bottom: 12px; padding: 10px; background: var(--card-base); border-radius: 6px; border: 1px solid var(--border);\">' +\n          '<div style=\"font-weight: 600; font-size: 0.85rem; margin-bottom: 4px;\">' + cfgChanged + ' Configuration</div>';\n        if (diff.config.hasChanges) {\n          html += '<div style=\"font-size: 0.8rem; color: #f39c12;\">Configuration differs \u2014 restoring will replace current settings</div>';\n        } else {\n          html += '<div style=\"font-size: 0.8rem; color: var(--ok-fg);\">No changes</div>';\n        }\n        html += '</div>';\n      }\n\n      html += '<button id=\"compare-close-btn\" style=\"padding: 8px 20px; background: var(--accent); border: none; color: white; border-radius: 6px; cursor: pointer; font-weight: 500;\">Close</button>' +\n        '</div></div>';\n\n      document.body.insertAdjacentHTML('beforeend', html);\n      document.getElementById('compare-close-btn')?.addEventListener('click', function() {\n        document.getElementById('compare-overlay')?.remove();\n      });\n      document.getElementById('compare-overlay')?.addEventListener('click', function(e) {\n        if (e.target === this) this.remove();\n      });\n    } catch (e) {\n      showNotification('Compare error: ' + e.message, 'error');\n    }\n  }\n\n  async function restoreBackupFile(appId, filename) {\n    if (!confirm('Restore ' + filename + ' for ' + appId + '?\\n\\nThis will replace current configuration, credentials, and data. Containers will be restarted.')) return;\n\n    try {\n      var res = await secureFetch('/api/v1/apps/' + encodeURIComponent(appId) + '/revert/' + encodeURIComponent(filename), {\n        method: 'POST',\n        headers: { 'Content-Type': 'application/json' },\n        body: JSON.stringify({ restartContainers: true })\n      });\n      var data = await res.json();\n      if (data.success) {\n        showNotification(appId + ' restored to ' + filename, 'success');\n        setTimeout(function() { location.reload(); }, 1500);\n      } else {\n        showNotification('Restore failed: ' + (data.error || 'Unknown'), 'error');\n      }\n    } catch (e) {\n      showNotification('Restore error: ' + e.message, 'error');\n    }\n  }\n})();\n;\n// ========== RESOURCE MONITOR (Enhanced) ==========\n(function() {\n  // Inject modal HTML\n  injectModal('stats-modal', `<div id=\"stats-modal\" class=\"weather-modal\">\n    <div class=\"weather-modal-content\" style=\"min-width: 750px; max-width: 950px;\">\n      <h3>\uD83D\uDCCA Resource Monitor</h3>\n      <p class=\"modal-subtitle\">\n        Real-time and historical CPU, memory, network, and disk usage for containers.\n      </p>\n\n      <!-- Tab bar -->\n      <div class=\"panel-tabs\">\n        <button class=\"panel-tab active\" data-panel=\"stats-live\">Live Stats</button>\n        <button class=\"panel-tab\" data-panel=\"stats-aggregated\">24h Summary</button>\n        <button class=\"panel-tab\" data-panel=\"stats-history\">History</button>\n        <button class=\"panel-tab\" data-panel=\"stats-alerts\">Alerts</button>\n      </div>\n\n      <!-- Tab: Live Stats -->\n      <div id=\"stats-live\" class=\"panel-section active\">\n        <div id=\"stats-container\" class=\"scroll-container\">\n          <div style=\"text-align: center; padding: 40px; color: var(--muted);\">\n            <span class=\"brand-spinner\"></span> Loading container stats...\n          </div>\n        </div>\n      </div>\n\n      <!-- Tab: 24h Aggregated Summary -->\n      <div id=\"stats-aggregated\" class=\"panel-section\">\n        <div id=\"stats-aggregated-container\" class=\"scroll-container\">\n          <div class=\"panel-empty\">\n            <span class=\"empty-icon\">\uD83D\uDCC8</span>\n            Loading 24-hour aggregated metrics...\n          </div>\n        </div>\n      </div>\n\n      <!-- Tab: Long-term History -->\n      <div id=\"stats-history\" class=\"panel-section\">\n        <div style=\"display: flex; gap: 8px; align-items: center; margin-bottom: 12px; flex-wrap: wrap;\">\n          <label style=\"font-size: 0.85rem; color: var(--muted);\">Container:</label>\n          <select id=\"stats-history-container\" style=\"padding: 4px 8px; background: var(--card-base); border: 1px solid var(--border); color: var(--fg); border-radius: 4px; font-size: 0.85rem; flex: 1; min-width: 180px;\"></select>\n          <div id=\"stats-history-range-buttons\" style=\"display: flex; gap: 4px;\">\n            <button class=\"stats-range-btn active\" data-range=\"1h\">1h</button>\n            <button class=\"stats-range-btn\" data-range=\"24h\">24h</button>\n            <button class=\"stats-range-btn\" data-range=\"7d\">7d</button>\n            <button class=\"stats-range-btn\" data-range=\"30d\">30d</button>\n            <button class=\"stats-range-btn\" data-range=\"1y\">1y</button>\n          </div>\n        </div>\n        <div id=\"stats-history-container-area\" class=\"scroll-container\">\n          <div class=\"panel-empty\">\n            <span class=\"empty-icon\">\uD83D\uDCCA</span>\n            Choose a container and time range to view history.\n          </div>\n        </div>\n      </div>\n\n      <!-- Tab: Alert Configuration -->\n      <div id=\"stats-alerts\" class=\"panel-section\">\n        <div id=\"stats-alerts-container\" class=\"scroll-container\">\n          <div class=\"panel-empty\">\n            <span class=\"empty-icon\">\uD83D\uDD14</span>\n            Loading alert configurations...\n          </div>\n        </div>\n      </div>\n\n      <!-- Auto-refresh toggle (bottom bar) -->\n      <div class=\"panel-bottom-bar\">\n        <label class=\"checkbox-label\" style=\"font-size: 0.85rem;\">\n          <input type=\"checkbox\" id=\"stats-auto-refresh\" checked />\n          Auto-refresh every 5s\n        </label>\n        <button id=\"stats-refresh-btn\" class=\"btn-sm\">\uD83D\uDD04 Refresh Now</button>\n        <span id=\"stats-last-update\" class=\"text-auto-right\"></span>\n      </div>\n\n      <!-- Close Button -->\n      <div class=\"weather-modal-buttons modal-footer-bar\">\n        <button id=\"stats-cancel\">Close</button>\n      </div>\n    </div>\n  </div>`);\n\n  const modal = document.getElementById('stats-modal');\n  const openBtn = document.getElementById('container-stats-btn');\n  const cancelBtn = document.getElementById('stats-cancel');\n  const refreshBtn = document.getElementById('stats-refresh-btn');\n  const autoRefreshCheckbox = document.getElementById('stats-auto-refresh');\n  const container = document.getElementById('stats-container');\n  const aggregatedContainer = document.getElementById('stats-aggregated-container');\n  const alertsContainer = document.getElementById('stats-alerts-container');\n  const lastUpdateSpan = document.getElementById('stats-last-update');\n\n  let refreshInterval = null;\n  let cachedMonitoringData = null;\n\n  function formatBytes(bytes) {\n    if (bytes === 0 || !bytes) return '0 B';\n    const k = 1024;\n    const sizes = ['B', 'KB', 'MB', 'GB'];\n    const i = Math.floor(Math.log(bytes) / Math.log(k));\n    return parseFloat((bytes / Math.pow(k, i)).toFixed(1)) + ' ' + sizes[i];\n  }\n\n  function getCpuColor(percent) {\n    if (percent < 30) return '#2ecc71';\n    if (percent < 70) return '#f39c12';\n    return '#e74c3c';\n  }\n\n  function getMemColor(percent) {\n    if (percent < 50) return '#2ecc71';\n    if (percent < 80) return '#f39c12';\n    return '#e74c3c';\n  }\n\n  async function loadStats() {\n    try {\n      // Try new monitoring API first, fall back to old\n      let stats = null;\n      let isNewApi = false;\n      try {\n        const res = await fetch('/api/v1/monitoring/stats');\n        const data = await res.json();\n        if (data.success && data.stats) { stats = data.stats; isNewApi = true; cachedMonitoringData = data.stats; }\n      } catch (_) {}\n\n      if (!isNewApi) {\n        const response = await fetch('/api/v1/stats/containers');\n        const data = await response.json();\n        if (data.success && data.stats) {\n          // Convert array format to object format\n          stats = {};\n          for (const s of data.stats) {\n            stats[s.name] = { name: s.name, current: { cpu: s.cpu, memory: { percent: s.memory.percent, usage: s.memory.used, limit: s.memory.limit, usageMB: Math.round(s.memory.used / 1048576), limitMB: Math.round(s.memory.limit / 1048576) }, network: { rxBytes: s.network.rx, txBytes: s.network.tx, rxMB: (s.network.rx / 1048576).toFixed(1), txMB: (s.network.tx / 1048576).toFixed(1) }, disk: { readMB: 0, writeMB: 0 } }, status: s.status };\n          }\n          cachedMonitoringData = stats;\n        }\n      }\n\n      if (!stats || Object.keys(stats).length === 0) {\n        container.innerHTML = '<div style=\"text-align: center; padding: 40px; color: var(--muted);\">No running containers found</div>';\n        return;\n      }\n\n      let html = '<div style=\"display: flex; flex-direction: column; gap: 8px;\">';\n\n      for (const [id, info] of Object.entries(stats)) {\n        const cur = info.current || info;\n        const cpu = cur.cpu?.percent || 0;\n        const mem = cur.memory?.percent || 0;\n        const cpuColor = getCpuColor(cpu);\n        const memColor = getMemColor(mem);\n        const memUsed = cur.memory?.usage || cur.memory?.used || 0;\n        const memLimit = cur.memory?.limit || 0;\n        const netRx = cur.network?.rxBytes || cur.network?.rx || 0;\n        const netTx = cur.network?.txBytes || cur.network?.tx || 0;\n        const agg = info.aggregated;\n\n        html += `\n          <div style=\"padding: 12px; background: var(--card-base); border-radius: 8px; border: 1px solid var(--border);\">\n            <div style=\"display: flex; align-items: center; gap: 12px; margin-bottom: 10px;\">\n              <span style=\"font-weight: 600; flex: 1;\">${info.name || id}</span>\n              ${agg ? `<span style=\"font-size: 0.65rem; color: var(--muted); padding: 2px 6px; background: color-mix(in srgb, var(--accent) 10%, transparent); border-radius: 4px;\">avg ${agg.cpu?.avg?.toFixed(0) || 0}% cpu</span>` : ''}\n              <span style=\"font-size: 0.75rem; color: var(--muted); background: var(--base); padding: 2px 8px; border-radius: 4px;\">${info.status || 'running'}</span>\n            </div>\n            <div style=\"display: grid; grid-template-columns: repeat(3, 1fr); gap: 12px;\">\n              <div>\n                <div style=\"font-size: 0.7rem; color: var(--muted); margin-bottom: 4px;\">CPU</div>\n                <div style=\"display: flex; align-items: center; gap: 8px;\">\n                  <div style=\"flex: 1; height: 6px; background: var(--base); border-radius: 3px; overflow: hidden;\">\n                    <div style=\"height: 100%; width: ${Math.min(cpu, 100)}%; background: ${cpuColor}; border-radius: 3px; transition: width 0.3s;\"></div>\n                  </div>\n                  <span style=\"font-size: 0.8rem; font-weight: 500; color: ${cpuColor}; min-width: 45px; text-align: right;\">${cpu.toFixed(1)}%</span>\n                </div>\n              </div>\n              <div>\n                <div style=\"font-size: 0.7rem; color: var(--muted); margin-bottom: 4px;\">Memory</div>\n                <div style=\"display: flex; align-items: center; gap: 8px;\">\n                  <div style=\"flex: 1; height: 6px; background: var(--base); border-radius: 3px; overflow: hidden;\">\n                    <div style=\"height: 100%; width: ${Math.min(mem, 100)}%; background: ${memColor}; border-radius: 3px; transition: width 0.3s;\"></div>\n                  </div>\n                  <span style=\"font-size: 0.8rem; font-weight: 500; color: ${memColor}; min-width: 45px; text-align: right;\">${mem.toFixed(1)}%</span>\n                </div>\n                <div style=\"font-size: 0.65rem; color: var(--muted); margin-top: 2px;\">${formatBytes(memUsed)} / ${formatBytes(memLimit)}</div>\n              </div>\n              <div>\n                <div style=\"font-size: 0.7rem; color: var(--muted); margin-bottom: 4px;\">Network</div>\n                <div style=\"font-size: 0.8rem;\">\n                  <span style=\"color: #3498db;\">\u2193 ${formatBytes(netRx)}</span>\n                  <span style=\"color: var(--muted); margin: 0 4px;\">/</span>\n                  <span style=\"color: #e74c3c;\">\u2191 ${formatBytes(netTx)}</span>\n                </div>\n              </div>\n            </div>\n          </div>`;\n      }\n      html += '</div>';\n      container.innerHTML = html;\n      lastUpdateSpan.textContent = 'Updated: ' + new Date().toLocaleTimeString();\n    } catch (e) {\n      container.innerHTML = `<div style=\"text-align: center; padding: 40px; color: var(--bad-fg);\">\u274C Failed to load stats: ${escapeHtml(e.message)}</div>`;\n    }\n  }\n\n  // === 24h Aggregated Tab ===\n  async function loadAggregated() {\n    if (!aggregatedContainer) return;\n    const data = cachedMonitoringData;\n    if (!data || Object.keys(data).length === 0) {\n      aggregatedContainer.innerHTML = '<div class=\"panel-empty\"><span class=\"empty-icon\">\uD83D\uDCC8</span>No monitoring data available. Open the Live Stats tab first.</div>';\n      return;\n    }\n    let html = '<div style=\"display: flex; flex-direction: column; gap: 12px;\">';\n    for (const [id, info] of Object.entries(data)) {\n      const agg = info.aggregated;\n      if (!agg) continue;\n      html += `<div style=\"padding: 12px; background: var(--card-base); border-radius: 8px; border: 1px solid var(--border);\">\n        <div style=\"font-weight: 600; margin-bottom: 10px;\">${info.name || id}</div>\n        <div style=\"display: grid; grid-template-columns: repeat(4, 1fr); gap: 8px;\">\n          <div class=\"stat-mini-card\"><span class=\"stat-val\">${agg.cpu?.avg?.toFixed(1) || 0}%</span><span class=\"stat-lbl\">Avg CPU</span></div>\n          <div class=\"stat-mini-card\"><span class=\"stat-val\">${agg.cpu?.max?.toFixed(1) || 0}%</span><span class=\"stat-lbl\">Max CPU</span></div>\n          <div class=\"stat-mini-card\"><span class=\"stat-val\">${agg.memory?.avg?.toFixed(1) || 0}%</span><span class=\"stat-lbl\">Avg Mem</span></div>\n          <div class=\"stat-mini-card\"><span class=\"stat-val\">${agg.memory?.max?.toFixed(1) || 0}%</span><span class=\"stat-lbl\">Max Mem</span></div>\n        </div>\n        ${agg.dataPoints ? `<div style=\"font-size: 0.7rem; color: var(--muted); margin-top: 6px;\">${agg.dataPoints} data points over ${agg.timeRange || 24}h</div>` : ''}\n      </div>`;\n    }\n    html += '</div>';\n    aggregatedContainer.innerHTML = html;\n  }\n\n  // === Alerts Tab ===\n  async function loadAlerts() {\n    if (!alertsContainer) return;\n    alertsContainer.innerHTML = '<div class=\"panel-empty\"><span class=\"brand-spinner\"></span> Loading alerts...</div>';\n\n    const data = cachedMonitoringData;\n    if (!data || Object.keys(data).length === 0) {\n      alertsContainer.innerHTML = '<div class=\"panel-empty\"><span class=\"empty-icon\">\uD83D\uDD14</span>No containers found. Open the Live Stats tab first.</div>';\n      return;\n    }\n\n    // Check premium status for config section visibility\n    let isPremium = false;\n    try {\n      const resp = await fetch('/api/v1/license/feature/resource-alerts');\n      const ld = await resp.json();\n      isPremium = ld.available;\n    } catch (_) { isPremium = false; }\n\n    // Fetch alert history\n    let alertHistory = [];\n    try {\n      const hr = await fetch('/api/v1/monitoring/alerts?limit=50');\n      const hd = await hr.json();\n      if (hd.success) alertHistory = hd.history || [];\n    } catch (_) {}\n\n    // Fetch all alert configs\n    let allConfigs = {};\n    try {\n      const cr = await fetch('/api/v1/monitoring/alerts/config');\n      const cd = await cr.json();\n      if (cd.success) allConfigs = cd.configs || {};\n    } catch (_) {}\n\n    const containers = Object.entries(data);\n    const containerRows = containers.map(([id, info]) => {\n      const cfg = allConfigs[id] || { cpuThreshold: 80, memoryThreshold: 90, diskIOThreshold: 50, autoRestart: false, enabled: false };\n      return `\n        <tr data-container=\"${id}\">\n          <td style=\"font-weight: 600; padding: 8px;\">${info.name || id}</td>\n          <td style=\"padding: 4px 8px;\"><input type=\"number\" class=\"alert-cpu\" value=\"${cfg.cpuThreshold ?? 80}\" min=\"0\" max=\"100\" style=\"width: 60px; font-size: 0.8rem; padding: 2px 4px;\" ${isPremium ? '' : 'disabled'} /></td>\n          <td style=\"padding: 4px 8px;\"><input type=\"number\" class=\"alert-mem\" value=\"${cfg.memoryThreshold ?? 90}\" min=\"0\" max=\"100\" style=\"width: 60px; font-size: 0.8rem; padding: 2px 4px;\" ${isPremium ? '' : 'disabled'} /></td>\n          <td style=\"padding: 4px 8px;\"><input type=\"number\" class=\"alert-disk\" value=\"${cfg.diskIOThreshold ?? 50}\" min=\"0\" max=\"1000\" style=\"width: 70px; font-size: 0.8rem; padding: 2px 4px;\" ${isPremium ? '' : 'disabled'} /></td>\n          <td style=\"padding: 4px 8px;\"><input type=\"checkbox\" class=\"alert-autorestart\" ${cfg.autoRestart ? 'checked' : ''} ${isPremium ? '' : 'disabled'} /></td>\n          <td style=\"padding: 4px 8px;\">\n            <button class=\"alert-test-btn btn-xs\" data-container=\"${id}\" data-name=\"${info.name || id}\" style=\"padding: 2px 8px; font-size: 0.75rem; background: var(--card-base); border: 1px solid var(--border); border-radius: 4px; cursor: pointer;\">Test</button>\n          </td>\n        </tr>\n      `;\n    }).join('');\n\n    const historyRows = alertHistory.map(entry => {\n      const time = new Date(entry.timestamp).toLocaleString();\n      const notifiedMark = entry.notified ? '\u2713' : '\u2014';\n      return `\n        <tr>\n          <td style=\"padding: 6px 8px; font-size: 0.8rem; color: var(--muted);\">${time}</td>\n          <td style=\"padding: 6px 8px; font-weight: 500;\">${entry.containerName || entry.containerId}</td>\n          <td style=\"padding: 6px 8px; text-transform: capitalize;\">${entry.metric || entry.type}</td>\n          <td style=\"padding: 6px 8px;\">${typeof entry.value === 'number' ? entry.value.toFixed(1) : entry.value}${entry.metric === 'disk' ? ' MB/s' : '%'}</td>\n          <td style=\"padding: 6px 8px; text-align: center;\">${notifiedMark}</td>\n          <td style=\"padding: 6px 8px; font-size: 0.75rem; color: ${entry.autoRestartTriggered ? '#f39c12' : 'var(--muted)'};\">${entry.autoRestartTriggered ? '\u21BB' : ''}</td>\n        </tr>\n      `;\n    }).join('');\n\n    const configSection = isPremium ? `\n      <div style=\"margin-bottom: 20px;\">\n        <div style=\"display: flex; align-items: center; justify-content: space-between; margin-bottom: 10px;\">\n          <h4 style=\"margin: 0; font-size: 0.9rem;\">\u2699\uFE0F Alert Configuration</h4>\n          <a href=\"#\" id=\"go-to-notifications\" style=\"font-size: 0.8rem; color: var(--accent); text-decoration: none;\">Configure notifications \u2192</a>\n        </div>\n        <div style=\"overflow-x: auto;\">\n          <table style=\"width: 100%; border-collapse: collapse; font-size: 0.85rem;\">\n            <thead>\n              <tr style=\"border-bottom: 1px solid var(--border);\">\n                <th style=\"text-align: left; padding: 6px 8px; color: var(--muted);\">Container</th>\n                <th style=\"text-align: left; padding: 6px 8px; color: var(--muted);\">CPU %</th>\n                <th style=\"text-align: left; padding: 6px 8px; color: var(--muted);\">Mem %</th>\n                <th style=\"text-align: left; padding: 6px 8px; color: var(--muted);\">Disk I/O MB/s</th>\n                <th style=\"text-align: center; padding: 6px 8px; color: var(--muted);\">Auto-Restart</th>\n                <th style=\"padding: 6px 8px;\"></th>\n              </tr>\n            </thead>\n            <tbody>${containerRows}</tbody>\n          </table>\n        </div>\n        <div style=\"margin-top: 12px; display: flex; justify-content: flex-end;\">\n          <button id=\"save-all-alerts\" style=\"padding: 6px 16px; font-size: 0.85rem; background: var(--accent); color: var(--base); border: none; border-radius: 4px; cursor: pointer; font-weight: 600;\">Save All</button>\n        </div>\n      </div>\n    ` : `\n      <div style=\"margin-bottom: 20px; padding: 12px; background: rgba(241,196,15,0.1); border: 1px solid rgba(241,196,15,0.3); border-radius: 8px; text-align: center;\">\n        <span style=\"color: #f1c40f; font-weight: 600; font-size: 0.85rem;\">\u2B50 Premium Feature</span>\n        <p style=\"margin: 6px 0 0; font-size: 0.75rem; color: var(--muted);\">Upgrade to configure resource alert thresholds per container.</p>\n        <button id=\"upgrade-for-alerts\" style=\"margin-top: 8px; padding: 4px 12px; font-size: 0.75rem; background: #f1c40f; color: #000; border: none; border-radius: 4px; cursor: pointer; font-weight: 600;\">Upgrade Now</button>\n      </div>\n    `;\n\n    alertsContainer.innerHTML = `\n      ${configSection}\n      <div>\n        <h4 style=\"margin: 0 0 10px; font-size: 0.9rem;\">\uD83D\uDCCB Recent Alerts</h4>\n        ${historyRows ? `\n          <div style=\"overflow-x: auto;\">\n            <table style=\"width: 100%; border-collapse: collapse; font-size: 0.8rem;\">\n              <thead>\n                <tr style=\"border-bottom: 1px solid var(--border);\">\n                  <th style=\"text-align: left; padding: 6px 8px; color: var(--muted);\">Time</th>\n                  <th style=\"text-align: left; padding: 6px 8px; color: var(--muted);\">Container</th>\n                  <th style=\"text-align: left; padding: 6px 8px; color: var(--muted);\">Metric</th>\n                  <th style=\"text-align: left; padding: 6px 8px; color: var(--muted);\">Value</th>\n                  <th style=\"text-align: center; padding: 6px 8px; color: var(--muted);\">\u2713?</th>\n                  <th style=\"padding: 6px 8px;\"></th>\n                </tr>\n              </thead>\n              <tbody>${historyRows}</tbody>\n            </table>\n          </div>\n        ` : '<div style=\"color: var(--muted); text-align: center; padding: 20px;\">No alerts recorded yet.</div>'}\n      </div>\n    `;\n\n    // Wire up save-all button\n    document.getElementById('save-all-alerts')?.addEventListener('click', async () => {\n      const configs = {};\n      document.querySelectorAll('#stats-alerts-container tr[data-container]').forEach(row => {\n        const cId = row.dataset.container;\n        configs[cId] = {\n          cpuThreshold: parseInt(row.querySelector('.alert-cpu')?.value) || 80,\n          memoryThreshold: parseInt(row.querySelector('.alert-mem')?.value) || 90,\n          diskIOThreshold: parseInt(row.querySelector('.alert-disk')?.value) || 50,\n          autoRestart: !!row.querySelector('.alert-autorestart')?.checked,\n          enabled: true\n        };\n      });\n      try {\n        const res = await secureFetch('/api/v1/monitoring/alerts/config', {\n          method: 'POST',\n          headers: { 'Content-Type': 'application/json' },\n          body: JSON.stringify({ configs })\n        });\n        const d = await res.json();\n        const btn = document.getElementById('save-all-alerts');\n        btn.textContent = d.success ? '\u2705 Saved' : '\u274C Failed';\n        setTimeout(() => { btn.textContent = 'Save All'; }, 2000);\n      } catch (e) {\n        const btn = document.getElementById('save-all-alerts');\n        btn.textContent = '\u274C Error';\n        setTimeout(() => { btn.textContent = 'Save All'; }, 2000);\n      }\n    });\n\n    // Wire up notification settings link\n    document.getElementById('go-to-notifications')?.addEventListener('click', (e) => {\n      e.preventDefault();\n      modal.classList.remove('show');\n      stopAutoRefresh();\n      document.getElementById('manage-notifications')?.click();\n    });\n\n    // Wire up test buttons\n    document.querySelectorAll('.alert-test-btn').forEach(btn => {\n      btn.addEventListener('click', async () => {\n        const orig = btn.textContent;\n        btn.textContent = '...';\n        try {\n          await secureFetch(`/api/v1/monitoring/alerts/${btn.dataset.container}/test`, { method: 'POST' });\n          btn.textContent = '\u2705';\n          showNotification('Test alert sent for ' + btn.dataset.name, 'success', 3000);\n        } catch (e) {\n          btn.textContent = '\u274C';\n        }\n        setTimeout(() => { btn.textContent = orig; }, 2000);\n      });\n    });\n\n    // Wire up upgrade button\n    document.getElementById('upgrade-for-alerts')?.addEventListener('click', () => {\n      modal.classList.remove('show');\n      stopAutoRefresh();\n      if (typeof openLicenseModal === 'function') openLicenseModal();\n    });\n  }\n\n  function startAutoRefresh() {\n    if (refreshInterval) clearInterval(refreshInterval);\n    if (autoRefreshCheckbox?.checked) {\n      refreshInterval = setInterval(loadStats, DC.POLL.STATS);\n    }\n  }\n\n  function stopAutoRefresh() {\n    if (refreshInterval) {\n      clearInterval(refreshInterval);\n      refreshInterval = null;\n    }\n  }\n\n  // Open modal\n  openBtn?.addEventListener('click', () => {\n    modal.classList.add('show');\n    loadStats();\n    startAutoRefresh();\n  });\n\n  // Close modal\n  cancelBtn?.addEventListener('click', () => {\n    modal.classList.remove('show');\n    stopAutoRefresh();\n  });\n\n  modal?.addEventListener('click', (e) => {\n    if (e.target === modal) {\n      modal.classList.remove('show');\n      stopAutoRefresh();\n    }\n  });\n\n  refreshBtn?.addEventListener('click', loadStats);\n\n  autoRefreshCheckbox?.addEventListener('change', () => {\n    if (autoRefreshCheckbox.checked) startAutoRefresh();\n    else stopAutoRefresh();\n  });\n\n  // Lazy-load tabs\n  document.querySelector('[data-panel=\"stats-aggregated\"]')?.addEventListener('click', loadAggregated);\n  document.querySelector('[data-panel=\"stats-alerts\"]')?.addEventListener('click', loadAlerts);\n\n  // === History Tab ===\n  const historyContainerSelect = document.getElementById('stats-history-container');\n  const historyArea = document.getElementById('stats-history-container-area');\n  const rangeButtons = document.querySelectorAll('.stats-range-btn');\n\n  let currentRange = '1h';\n\n  function rangeToMs(range) {\n    switch (range) {\n      case '1h':  return 60 * 60 * 1000;\n      case '24h': return 24 * 60 * 60 * 1000;\n      case '7d':  return 7 * 24 * 60 * 60 * 1000;\n      case '30d': return 30 * 24 * 60 * 60 * 1000;\n      case '1y':  return 365 * 24 * 60 * 60 * 1000;\n      default:    return 60 * 60 * 1000;\n    }\n  }\n\n  function tierLabel(tier) {\n    if (tier === 'raw') return 'live (10s samples)';\n    if (tier === 'hourly') return 'hourly average';\n    if (tier === 'daily') return 'daily average';\n    return tier;\n  }\n\n  // Simple SVG sparkline \u2014 no external lib\n  function renderSparkline(samples, accessor, color, label, unit) {\n    if (!samples || samples.length === 0) {\n      return `<div style=\"text-align: center; color: var(--muted); padding: 20px;\">No data for ${escapeHtml(label)}</div>`;\n    }\n    const values = samples.map(accessor).filter(v => v != null);\n    if (values.length === 0) {\n      return `<div style=\"text-align: center; color: var(--muted); padding: 20px;\">No data for ${escapeHtml(label)}</div>`;\n    }\n    const max = Math.max(...values, 1);\n    const min = Math.min(...values, 0);\n    const range = max - min || 1;\n    const w = 600, h = 80, pad = 4;\n    const stepX = (w - pad * 2) / Math.max(values.length - 1, 1);\n    const points = values.map((v, i) => {\n      const x = pad + i * stepX;\n      const y = h - pad - ((v - min) / range) * (h - pad * 2);\n      return `${x.toFixed(1)},${y.toFixed(1)}`;\n    }).join(' ');\n    const last = values[values.length - 1];\n    const avg = values.reduce((a, b) => a + b, 0) / values.length;\n    return `\n      <div style=\"margin-bottom: 14px;\">\n        <div style=\"display: flex; align-items: baseline; gap: 12px; margin-bottom: 4px;\">\n          <span style=\"font-weight: 600; font-size: 0.9rem;\">${escapeHtml(label)}</span>\n          <span style=\"font-size: 0.75rem; color: var(--muted);\">last ${last.toFixed(1)}${unit} \u00B7 avg ${avg.toFixed(1)}${unit} \u00B7 max ${max.toFixed(1)}${unit}</span>\n        </div>\n        <svg viewBox=\"0 0 ${w} ${h}\" preserveAspectRatio=\"none\" style=\"width: 100%; height: ${h}px; background: var(--base); border-radius: 4px;\">\n          <polyline fill=\"none\" stroke=\"${color}\" stroke-width=\"1.5\" points=\"${points}\" />\n        </svg>\n      </div>\n    `;\n  }\n\n  function populateHistoryContainerSelect() {\n    if (!historyContainerSelect) return;\n    const data = cachedMonitoringData || {};\n    const previous = historyContainerSelect.value;\n    const entries = Object.entries(data);\n    if (entries.length === 0) {\n      historyContainerSelect.innerHTML = '<option value=\"\">No containers</option>';\n      return;\n    }\n    historyContainerSelect.innerHTML = entries\n      .map(([id, info]) => `<option value=\"${escapeHtml(id)}\">${escapeHtml(info.name || id)}</option>`)\n      .join('');\n    if (previous && data[previous]) historyContainerSelect.value = previous;\n  }\n\n  async function loadHistory() {\n    if (!historyArea || !historyContainerSelect) return;\n    const containerId = historyContainerSelect.value;\n    if (!containerId) {\n      historyArea.innerHTML = '<div class=\"panel-empty\"><span class=\"empty-icon\">\uD83D\uDCCA</span>No container selected.</div>';\n      return;\n    }\n    const endTime = Date.now();\n    const startTime = endTime - rangeToMs(currentRange);\n    historyArea.innerHTML = '<div class=\"panel-empty\"><span class=\"brand-spinner\"></span> Loading history...</div>';\n\n    try {\n      const res = await fetch(`/api/v1/monitoring/history/${encodeURIComponent(containerId)}?startTime=${startTime}&endTime=${endTime}`);\n      const data = await res.json();\n      if (!data.success) throw new Error(data.error || 'Failed to load history');\n\n      const samples = data.samples || [];\n      const tier = data.tier || 'raw';\n\n      if (samples.length === 0) {\n        historyArea.innerHTML = `<div class=\"panel-empty\"><span class=\"empty-icon\">\uD83D\uDCCA</span>No data for the last ${currentRange}. Tier: ${tierLabel(tier)}.</div>`;\n        return;\n      }\n\n      // Different shape between raw vs rolled-up samples\n      const isRaw = tier === 'raw';\n      const cpuAccessor = isRaw ? (s) => s.cpu?.percent : (s) => s.cpu?.avg;\n      const memAccessor = isRaw ? (s) => s.memory?.percent : (s) => s.memory?.avgPercent;\n      const netRxAccessor = isRaw ? (s) => (s.network?.rxMB || 0) : (s) => (s.network?.rxMB || 0);\n      const netTxAccessor = isRaw ? (s) => (s.network?.txMB || 0) : (s) => (s.network?.txMB || 0);\n\n      let html = `\n        <div style=\"font-size: 0.75rem; color: var(--muted); margin-bottom: 8px;\">\n          ${samples.length} samples \u00B7 ${escapeHtml(tierLabel(tier))} \u00B7 ${new Date(startTime).toLocaleString()} \u2192 ${new Date(endTime).toLocaleString()}\n        </div>\n      `;\n      html += renderSparkline(samples, cpuAccessor, '#2ecc71', 'CPU', '%');\n      html += renderSparkline(samples, memAccessor, '#3498db', 'Memory', '%');\n      html += renderSparkline(samples, netRxAccessor, '#9b59b6', 'Network RX', ' MB');\n      html += renderSparkline(samples, netTxAccessor, '#e67e22', 'Network TX', ' MB');\n\n      historyArea.innerHTML = html;\n    } catch (e) {\n      historyArea.innerHTML = `<div class=\"panel-empty\"><span class=\"empty-icon\">\u26A0\uFE0F</span>Failed to load history: ${escapeHtml(e.message)}</div>`;\n    }\n  }\n\n  rangeButtons.forEach(btn => {\n    btn.addEventListener('click', () => {\n      rangeButtons.forEach(b => b.classList.remove('active'));\n      btn.classList.add('active');\n      currentRange = btn.dataset.range;\n      loadHistory();\n    });\n  });\n\n  historyContainerSelect?.addEventListener('change', loadHistory);\n\n  document.querySelector('[data-panel=\"stats-history\"]')?.addEventListener('click', () => {\n    populateHistoryContainerSelect();\n    loadHistory();\n  });\n})();\n;\n// ========== HEALTH CHECK DASHBOARD ==========\n(function() {\n  // Inject modal HTML\n  injectModal('health-modal', `<div id=\"health-modal\" class=\"weather-modal\">\n    <div class=\"weather-modal-content\" style=\"min-width: 800px; max-width: 1000px;\">\n      <h3>\uD83C\uDFE5 Health Check Dashboard</h3>\n      <p class=\"modal-subtitle\">\n        Service uptime tracking, SLA monitoring, and incident management.\n      </p>\n\n      <div class=\"panel-tabs\">\n        <button class=\"panel-tab active\" data-panel=\"health-status\">Status</button>\n        <button class=\"panel-tab\" data-panel=\"health-incidents\">Incidents</button>\n        <button class=\"panel-tab\" data-panel=\"health-config\">Configure</button>\n      </div>\n\n      <!-- Tab: Status -->\n      <div id=\"health-status\" class=\"panel-section active\">\n        <div id=\"health-status-container\" class=\"scroll-container\">\n          <div class=\"panel-empty\"><span class=\"brand-spinner\"></span> Loading health status...</div>\n        </div>\n      </div>\n\n      <!-- Tab: Incidents -->\n      <div id=\"health-incidents\" class=\"panel-section\">\n        <div id=\"health-incidents-container\" class=\"scroll-container\">\n          <div class=\"panel-empty\"><span class=\"empty-icon\">\uD83D\uDEA8</span> Loading incidents...</div>\n        </div>\n      </div>\n\n      <!-- Tab: Configure -->\n      <div id=\"health-config\" class=\"panel-section\">\n        <div id=\"health-config-container\" class=\"scroll-container\">\n          <div class=\"panel-empty\"><span class=\"empty-icon\">\u2699\uFE0F</span> Loading configuration...</div>\n        </div>\n\n        <!-- Global Settings: retention, polling intervals, max entries, disk-usage threshold -->\n        <div id=\"health-global-settings\" style=\"margin-top: 16px; padding: 16px; border: 1px solid var(--border); border-radius: var(--radius); background: var(--card-base);\">\n          <h4 style=\"margin: 0 0 4px;\">\uD83C\uDF0D Global Settings</h4>\n          <p class=\"text-muted-sm\" style=\"margin: 0 0 12px;\">Applies to all health checks. Settings are stored locally in this browser.</p>\n          <div style=\"display: grid; grid-template-columns: 1fr 1fr; gap: 12px;\">\n            <div>\n              <label class=\"text-muted-sm\">Health Check Polling Interval (seconds)</label>\n              <input type=\"number\" id=\"health-setting-interval\" value=\"60\" min=\"5\" max=\"3600\" class=\"form-input\" />\n              <div style=\"font-size: 0.72rem; color: var(--muted); margin-top: 2px;\">How often each service's health endpoint is checked.</div>\n            </div>\n            <div>\n              <label class=\"text-muted-sm\">Stats Polling Interval (seconds)</label>\n              <input type=\"number\" id=\"health-setting-stats-interval\" value=\"30\" min=\"5\" max=\"3600\" class=\"form-input\" />\n              <div style=\"font-size: 0.72rem; color: var(--muted); margin-top: 2px;\">How often container statistics (CPU/memory) are sampled.</div>\n            </div>\n            <div>\n              <label class=\"text-muted-sm\">Max Entries Per Service</label>\n              <input type=\"number\" id=\"health-setting-max-entries\" value=\"500\" min=\"10\" max=\"100000\" class=\"form-input\" />\n              <div style=\"font-size: 0.72rem; color: var(--muted); margin-top: 2px;\">Cap on stored history records per service.</div>\n            </div>\n            <div>\n              <label class=\"text-muted-sm\">Data Retention (days)</label>\n              <input type=\"number\" id=\"health-setting-retention\" value=\"30\" min=\"1\" max=\"3650\" class=\"form-input\" />\n              <div style=\"font-size: 0.72rem; color: var(--muted); margin-top: 2px;\">Health history older than this is pruned.</div>\n            </div>\n            <div>\n              <label class=\"text-muted-sm\">Disk-Usage Warning (%)</label>\n              <input type=\"number\" id=\"health-setting-disk-threshold\" value=\"80\" min=\"50\" max=\"99\" class=\"form-input\" />\n              <div style=\"font-size: 0.72rem; color: var(--muted); margin-top: 2px;\">Warn when disk usage exceeds this level.</div>\n            </div>\n          </div>\n          <div style=\"margin-top: 12px; display: flex; gap: 8px; align-items: center;\">\n            <button id=\"health-global-save\" class=\"btn-accent-solid\">Save Global Settings</button>\n            <button id=\"health-global-reset\" class=\"btn-sm\">Reset to Defaults</button>\n            <span id=\"health-global-status\" style=\"font-size: 0.8rem; color: var(--muted);\"></span>\n          </div>\n        </div>\n\n        <!-- Add/Edit Health Check Form -->\n        <div id=\"health-config-form\" style=\"display: none; margin-top: 16px; padding: 16px; border: 1px solid var(--border); border-radius: var(--radius); background: var(--card-base);\">\n          <h4 id=\"health-form-title\" style=\"margin: 0 0 12px;\">Add Health Check</h4>\n          <div style=\"display: grid; grid-template-columns: 1fr 1fr; gap: 12px;\">\n            <div>\n              <label class=\"text-muted-sm\">Service ID</label>\n              <input type=\"text\" id=\"health-form-id\" placeholder=\"e.g. plex\" class=\"form-input\" />\n            </div>\n            <div>\n              <label class=\"text-muted-sm\">Display Name</label>\n              <input type=\"text\" id=\"health-form-name\" placeholder=\"e.g. Plex Media Server\" class=\"form-input\" />\n            </div>\n            <div style=\"grid-column: span 2;\">\n              <label class=\"text-muted-sm\">URL</label>\n              <input type=\"text\" id=\"health-form-url\" placeholder=\"https://plex.home\" class=\"form-input\" />\n            </div>\n            <div>\n              <label class=\"text-muted-sm\">Timeout (ms)</label>\n              <input type=\"number\" id=\"health-form-timeout\" value=\"10000\" class=\"form-input\" />\n            </div>\n            <div>\n              <label class=\"text-muted-sm\">Expected Status Codes</label>\n              <input type=\"text\" id=\"health-form-codes\" value=\"200\" placeholder=\"200, 301, 302\" class=\"form-input\" />\n            </div>\n            <div>\n              <label class=\"text-muted-sm\">SLA Target (%)</label>\n              <input type=\"number\" id=\"health-form-sla\" value=\"99.9\" step=\"0.1\" class=\"form-input\" />\n            </div>\n            <div>\n              <label class=\"text-muted-sm\">Slow Response Threshold (ms)</label>\n              <input type=\"number\" id=\"health-form-slow\" value=\"5000\" class=\"form-input\" />\n            </div>\n          </div>\n          <div style=\"margin-top: 12px; display: flex; gap: 8px; justify-content: flex-end;\">\n            <button id=\"health-form-cancel\">Cancel</button>\n            <button id=\"health-form-save\" class=\"btn-accent-solid\">Save</button>\n          </div>\n        </div>\n\n        <div style=\"margin-top: 12px;\">\n          <button id=\"health-add-btn\" class=\"btn-accent-solid\">+ Add Health Check</button>\n        </div>\n      </div>\n\n      <div class=\"panel-bottom-bar\">\n        <button id=\"health-refresh-btn\" class=\"btn-sm\">\uD83D\uDD04 Refresh</button>\n        <span id=\"health-last-update\" class=\"text-auto-right\"></span>\n      </div>\n\n      <div class=\"weather-modal-buttons modal-footer-bar\">\n        <button id=\"health-cancel\">Close</button>\n      </div>\n    </div>\n  </div>`);\n\n  const modal = document.getElementById('health-modal');\n  const openBtn = document.getElementById('health-check-btn');\n  const cancelBtn = document.getElementById('health-cancel');\n  const refreshBtn = document.getElementById('health-refresh-btn');\n  const statusContainer = document.getElementById('health-status-container');\n  const incidentsContainer = document.getElementById('health-incidents-container');\n  const configContainer = document.getElementById('health-config-container');\n  const lastUpdateSpan = document.getElementById('health-last-update');\n  const addBtn = document.getElementById('health-add-btn');\n  const formEl = document.getElementById('health-config-form');\n  const formTitle = document.getElementById('health-form-title');\n  const formCancel = document.getElementById('health-form-cancel');\n  const formSave = document.getElementById('health-form-save');\n\n  // ---- Global health settings (retention, polling intervals, max entries, disk threshold) ----\n  const HEALTH_SETTINGS_KEY = 'dashcaddy-health-settings';\n  const HEALTH_DEFAULTS = { retentionDays: 30, pollingInterval: 60, statsPollingInterval: 30, maxEntriesPerService: 500, diskUsageThreshold: 80 };\n  const globalSaveBtn = document.getElementById('health-global-save');\n  const globalResetBtn = document.getElementById('health-global-reset');\n  const globalStatusSpan = document.getElementById('health-global-status');\n  const retentionInput = document.getElementById('health-setting-retention');\n  const intervalInput = document.getElementById('health-setting-interval');\n  const statsIntervalInput = document.getElementById('health-setting-stats-interval');\n  const maxEntriesInput = document.getElementById('health-setting-max-entries');\n  const diskThresholdInput = document.getElementById('health-setting-disk-threshold');\n\n  function loadHealthSettings() {\n    try {\n      const raw = safeGet(HEALTH_SETTINGS_KEY);\n      const saved = raw ? JSON.parse(raw) : {};\n      return Object.assign({}, HEALTH_DEFAULTS, saved);\n    } catch (_) {\n      return Object.assign({}, HEALTH_DEFAULTS);\n    }\n  }\n\n  function applyHealthSettingsToUI() {\n    const s = loadHealthSettings();\n    if (retentionInput) retentionInput.value = s.retentionDays;\n    if (intervalInput) intervalInput.value = s.pollingInterval;\n    if (statsIntervalInput) statsIntervalInput.value = s.statsPollingInterval;\n    if (maxEntriesInput) maxEntriesInput.value = s.maxEntriesPerService;\n    if (diskThresholdInput) diskThresholdInput.value = s.diskUsageThreshold;\n  }\n\n  function saveHealthSettings() {\n    const settings = {\n      retentionDays: Math.max(1, Math.min(3650, parseInt(retentionInput?.value) || HEALTH_DEFAULTS.retentionDays)),\n      pollingInterval: Math.max(5, Math.min(3600, parseInt(intervalInput?.value) || HEALTH_DEFAULTS.pollingInterval)),\n      statsPollingInterval: Math.max(5, Math.min(3600, parseInt(statsIntervalInput?.value) || HEALTH_DEFAULTS.statsPollingInterval)),\n      maxEntriesPerService: Math.max(10, Math.min(100000, parseInt(maxEntriesInput?.value) || HEALTH_DEFAULTS.maxEntriesPerService)),\n      diskUsageThreshold: Math.max(50, Math.min(99, parseInt(diskThresholdInput?.value) || HEALTH_DEFAULTS.diskUsageThreshold))\n    };\n    try {\n      safeSet(HEALTH_SETTINGS_KEY, JSON.stringify(settings));\n      applyHealthSettingsToUI();\n      if (globalStatusSpan) {\n        globalStatusSpan.textContent = 'Saved \u2713';\n        globalStatusSpan.style.color = 'var(--ok-fg)';\n        setTimeout(() => { if (globalStatusSpan) globalStatusSpan.textContent = ''; }, 2500);\n      }\n      if (typeof showNotification === 'function') showNotification('Global health settings saved', 'success');\n    } catch (e) {\n      if (globalStatusSpan) { globalStatusSpan.textContent = 'Save failed'; globalStatusSpan.style.color = 'var(--bad-fg)'; }\n      if (typeof showNotification === 'function') showNotification('Failed to save settings: ' + e.message, 'error');\n    }\n  }\n\n  function resetHealthSettings() {\n    try {\n      safeSet(HEALTH_SETTINGS_KEY, JSON.stringify(HEALTH_DEFAULTS));\n    } catch (_) { /* ignore */ }\n    applyHealthSettingsToUI();\n    if (globalStatusSpan) {\n      globalStatusSpan.textContent = 'Reset to defaults \u2713';\n      globalStatusSpan.style.color = 'var(--ok-fg)';\n      setTimeout(() => { if (globalStatusSpan) globalStatusSpan.textContent = ''; }, 2500);\n    }\n  }\n\n  applyHealthSettingsToUI();\n  globalSaveBtn?.addEventListener('click', saveHealthSettings);\n  globalResetBtn?.addEventListener('click', resetHealthSettings);\n  // ---- End global health settings ----\n\n  let editingId = null;\n\n  function uptimeColor(pct) {\n    if (pct >= 99.9) return 'var(--ok-fg)';\n    if (pct >= 95) return '#f39c12';\n    return 'var(--bad-fg)';\n  }\n\n  function severityBadge(sev) {\n    const colors = { critical: 'var(--bad-fg)', high: '#ff6b6b', medium: '#f39c12', low: 'var(--muted)' };\n    return `<span style=\"padding: 2px 8px; border-radius: 4px; font-size: 0.75rem; background: ${colors[sev] || 'var(--muted)'}20; color: ${colors[sev] || 'var(--muted)'};\">${sev}</span>`;\n  }\n\n  async function loadStatus() {\n    try {\n      const res = await fetch('/api/v1/health-checks/status');\n      const data = await res.json();\n      if (!data.success || !data.status || Object.keys(data.status).length === 0) {\n        statusContainer.innerHTML = '<div class=\"panel-empty\"><span class=\"empty-icon\">\uD83C\uDFE5</span>No health checks configured. Go to the Configure tab to add services.</div>';\n        return;\n      }\n      const services = Object.values(data.status);\n      let html = '<table style=\"width: 100%; border-collapse: collapse; font-size: 0.85rem;\">';\n      html += '<tr style=\"border-bottom: 1px solid var(--border); color: var(--muted); text-align: left;\">';\n      html += '<th style=\"padding: 8px;\">Service</th><th style=\"padding: 8px;\">Status</th>';\n      html += '<th style=\"padding: 8px;\">Uptime 24h</th><th style=\"padding: 8px;\">Uptime 7d</th>';\n      html += '<th style=\"padding: 8px;\">Avg Response</th><th style=\"padding: 8px;\">Last Check</th></tr>';\n      for (const s of services) {\n        const isUp = s.status === 'up';\n        const dotColor = isUp ? 'var(--dot-ok)' : 'var(--dot-bad)';\n        const u24 = s.uptime?.['24h'] ?? '-';\n        const u7d = s.uptime?.['7d'] ?? '-';\n        const avgRt = s.avgResponseTime != null ? Math.round(s.avgResponseTime) + 'ms' : '-';\n        const lastCheck = s.timestamp ? timeAgo(s.timestamp) : '-';\n        html += `<tr style=\"border-bottom: 1px solid var(--border); cursor: pointer;\" data-health-id=\"${escapeHtml(s.serviceId)}\">`;\n        html += `<td style=\"padding: 8px; font-weight: 500;\">${escapeHtml(s.name || s.serviceId)}</td>`;\n        html += `<td style=\"padding: 8px;\"><span style=\"display: inline-block; width: 8px; height: 8px; border-radius: 50%; background: ${dotColor}; margin-right: 6px;\"></span>${isUp ? 'Up' : 'Down'}</td>`;\n        html += `<td style=\"padding: 8px; color: ${typeof u24 === 'number' ? uptimeColor(u24) : 'var(--muted)'};\">${typeof u24 === 'number' ? u24.toFixed(1) + '%' : u24}</td>`;\n        html += `<td style=\"padding: 8px; color: ${typeof u7d === 'number' ? uptimeColor(u7d) : 'var(--muted)'};\">${typeof u7d === 'number' ? u7d.toFixed(1) + '%' : u7d}</td>`;\n        html += `<td style=\"padding: 8px;\">${avgRt}</td>`;\n        html += `<td style=\"padding: 8px; color: var(--muted);\">${lastCheck}</td>`;\n        html += '</tr>';\n        html += `<tr id=\"health-detail-${escapeHtml(s.serviceId)}\" style=\"display: none;\"><td colspan=\"6\" style=\"padding: 12px; background: var(--bg); border-bottom: 1px solid var(--border);\"><div class=\"panel-empty\"><span class=\"brand-spinner\"></span> Loading details...</div></td></tr>`;\n      }\n      html += '</table>';\n      statusContainer.innerHTML = html;\n      lastUpdateSpan.textContent = 'Updated ' + new Date().toLocaleTimeString();\n\n      // Row click to expand details\n      statusContainer.querySelectorAll('tr[data-health-id]').forEach(row => {\n        row.addEventListener('click', async () => {\n          const id = row.dataset.healthId;\n          const detailRow = document.getElementById('health-detail-' + id);\n          if (!detailRow) return;\n          if (detailRow.style.display !== 'none') {\n            detailRow.style.display = 'none';\n            return;\n          }\n          detailRow.style.display = '';\n          try {\n            const r = await fetch(`/api/v1/health-checks/${id}/stats?hours=24`);\n            const d = await r.json();\n            if (d.success && d.stats) {\n              const st = d.stats;\n              const rt = st.responseTime || {};\n              detailRow.querySelector('td').innerHTML = `\n                <div style=\"display: grid; grid-template-columns: repeat(4, 1fr); gap: 12px; font-size: 0.82rem;\">\n                  <div><span style=\"color: var(--muted);\">Total Checks</span><br><strong>${st.totalChecks || 0}</strong></div>\n                  <div><span style=\"color: var(--muted);\">Uptime</span><br><strong style=\"color: ${uptimeColor(st.uptime || 0)};\">${(st.uptime || 0).toFixed(2)}%</strong></div>\n                  <div><span style=\"color: var(--muted);\">Avg Response</span><br><strong>${Math.round(rt.avg || 0)}ms</strong></div>\n                  <div><span style=\"color: var(--muted);\">P95 / P99</span><br><strong>${Math.round(rt.p95 || 0)}ms / ${Math.round(rt.p99 || 0)}ms</strong></div>\n                  <div><span style=\"color: var(--muted);\">Min Response</span><br><strong>${Math.round(rt.min || 0)}ms</strong></div>\n                  <div><span style=\"color: var(--muted);\">Max Response</span><br><strong>${Math.round(rt.max || 0)}ms</strong></div>\n                  <div><span style=\"color: var(--muted);\">Up Checks</span><br><strong style=\"color: var(--ok-fg);\">${st.upChecks || 0}</strong></div>\n                  <div><span style=\"color: var(--muted);\">Down Checks</span><br><strong style=\"color: var(--bad-fg);\">${st.downChecks || 0}</strong></div>\n                </div>`;\n            } else {\n              detailRow.querySelector('td').innerHTML = '<div class=\"panel-empty\">No detailed stats available for this period.</div>';\n            }\n          } catch (e) {\n            detailRow.querySelector('td').innerHTML = `<div class=\"panel-empty\" style=\"color: var(--bad-fg);\">Failed: ${escapeHtml(e.message)}</div>`;\n          }\n        });\n      });\n    } catch (e) {\n      statusContainer.innerHTML = `<div class=\"panel-empty\" style=\"color: var(--bad-fg);\">Failed to load health status: ${escapeHtml(e.message)}</div>`;\n    }\n  }\n\n  async function loadIncidents() {\n    try {\n      const [openRes, histRes] = await Promise.all([\n        fetch('/api/v1/health-checks/incidents'),\n        fetch('/api/v1/health-checks/incidents/history?limit=50')\n      ]);\n      const openData = await openRes.json();\n      const histData = await histRes.json();\n      let html = '';\n\n      // Open incidents\n      const open = (openData.success && openData.incidents) ? openData.incidents : [];\n      if (open.length > 0) {\n        html += '<div style=\"margin-bottom: 16px;\"><h4 style=\"color: var(--bad-fg); margin: 0 0 8px;\">Open Incidents (' + open.length + ')</h4>';\n        for (const inc of open) {\n          html += `<div style=\"padding: 10px 12px; margin-bottom: 8px; border: 1px solid var(--bad-fg)30; border-radius: 8px; background: var(--bad-bg);\">\n            <div style=\"display: flex; justify-content: space-between; align-items: center;\">\n              <span style=\"font-weight: 500;\">${escapeHtml(inc.serviceId)}</span>\n              <span>${severityBadge(inc.severity)}</span>\n            </div>\n            <div style=\"font-size: 0.82rem; color: var(--muted); margin-top: 4px;\">${escapeHtml(inc.message)}</div>\n            <div style=\"font-size: 0.75rem; color: var(--muted); margin-top: 4px;\">Started ${timeAgo(inc.createdAt)} \u00B7 ${inc.occurrences || 1} occurrence(s)</div>\n          </div>`;\n        }\n        html += '</div>';\n      } else {\n        html += '<div style=\"padding: 12px; margin-bottom: 16px; border: 1px solid var(--ok-fg)30; border-radius: 8px; background: var(--ok-bg); text-align: center; color: var(--ok-fg); font-size: 0.9rem;\">All services operational \u2014 no open incidents</div>';\n      }\n\n      // Incident history\n      const history = (histData.success && histData.history) ? histData.history : [];\n      if (history.length > 0) {\n        html += '<h4 style=\"margin: 0 0 8px; color: var(--muted);\">Incident History</h4>';\n        html += '<table style=\"width: 100%; border-collapse: collapse; font-size: 0.82rem;\">';\n        html += '<tr style=\"border-bottom: 1px solid var(--border); color: var(--muted);\"><th style=\"padding: 6px; text-align: left;\">Service</th><th style=\"padding: 6px; text-align: left;\">Type</th><th style=\"padding: 6px; text-align: left;\">Severity</th><th style=\"padding: 6px; text-align: left;\">Status</th><th style=\"padding: 6px; text-align: left;\">Duration</th><th style=\"padding: 6px; text-align: left;\">When</th></tr>';\n        for (const inc of history) {\n          const resolved = inc.status === 'resolved';\n          const dur = resolved && inc.duration ? (inc.duration < 60000 ? Math.round(inc.duration / 1000) + 's' : Math.round(inc.duration / 60000) + 'm') : '-';\n          html += `<tr style=\"border-bottom: 1px solid var(--border);\">`;\n          html += `<td style=\"padding: 6px;\">${escapeHtml(inc.serviceId)}</td>`;\n          html += `<td style=\"padding: 6px;\">${escapeHtml(inc.type)}</td>`;\n          html += `<td style=\"padding: 6px;\">${severityBadge(inc.severity)}</td>`;\n          html += `<td style=\"padding: 6px;\"><span style=\"color: ${resolved ? 'var(--ok-fg)' : 'var(--bad-fg)'};\">${inc.status}</span></td>`;\n          html += `<td style=\"padding: 6px;\">${dur}</td>`;\n          html += `<td style=\"padding: 6px; color: var(--muted);\">${timeAgo(inc.createdAt)}</td>`;\n          html += '</tr>';\n        }\n        html += '</table>';\n      }\n\n      incidentsContainer.innerHTML = html || '<div class=\"panel-empty\"><span class=\"empty-icon\">\uD83D\uDEA8</span>No incidents recorded yet.</div>';\n    } catch (e) {\n      incidentsContainer.innerHTML = `<div class=\"panel-empty\" style=\"color: var(--bad-fg);\">Failed: ${escapeHtml(e.message)}</div>`;\n    }\n  }\n\n  async function loadConfig() {\n    try {\n      const res = await fetch('/api/v1/health-checks/status');\n      const data = await res.json();\n      const services = data.success && data.status ? Object.values(data.status) : [];\n      if (services.length === 0) {\n        configContainer.innerHTML = '<div class=\"panel-empty\"><span class=\"empty-icon\">\u2699\uFE0F</span>No health checks configured yet. Click \"Add Health Check\" below.</div>';\n        return;\n      }\n      let html = '<table style=\"width: 100%; border-collapse: collapse; font-size: 0.85rem;\">';\n      html += '<tr style=\"border-bottom: 1px solid var(--border); color: var(--muted);\"><th style=\"padding: 8px; text-align: left;\">Service</th><th style=\"padding: 8px; text-align: left;\">Status</th><th style=\"padding: 8px; text-align: left;\">SLA Target</th><th style=\"padding: 8px; text-align: right;\">Actions</th></tr>';\n      for (const s of services) {\n        const isUp = s.status === 'up';\n        html += `<tr style=\"border-bottom: 1px solid var(--border);\">`;\n        html += `<td style=\"padding: 8px; font-weight: 500;\">${escapeHtml(s.name || s.serviceId)}</td>`;\n        html += `<td style=\"padding: 8px; color: ${isUp ? 'var(--ok-fg)' : 'var(--bad-fg)'};\">${isUp ? 'Up' : 'Down'}</td>`;\n        html += `<td style=\"padding: 8px;\">${s.sla?.target ? s.sla.target + '%' : '-'}</td>`;\n        html += `<td style=\"padding: 8px; text-align: right;\">`;\n        html += `<button onclick=\"document.dispatchEvent(new CustomEvent('health-edit', {detail:'${escapeHtml(s.serviceId)}'}))\" style=\"padding: 4px 10px; font-size: 0.78rem; margin-right: 4px;\">Edit</button>`;\n        html += `<button onclick=\"document.dispatchEvent(new CustomEvent('health-delete', {detail:'${escapeHtml(s.serviceId)}'}))\" style=\"padding: 4px 10px; font-size: 0.78rem; color: var(--bad-fg); border-color: var(--bad-fg);\">Delete</button>`;\n        html += '</td></tr>';\n      }\n      html += '</table>';\n      configContainer.innerHTML = html;\n    } catch (e) {\n      configContainer.innerHTML = `<div class=\"panel-empty\" style=\"color: var(--bad-fg);\">Failed: ${escapeHtml(e.message)}</div>`;\n    }\n  }\n\n  function showForm(id, name, url, timeout, codes, sla, slow) {\n    editingId = id || null;\n    formTitle.textContent = id ? 'Edit Health Check' : 'Add Health Check';\n    document.getElementById('health-form-id').value = id || '';\n    document.getElementById('health-form-id').disabled = !!id;\n    document.getElementById('health-form-name').value = name || '';\n    document.getElementById('health-form-url').value = url || '';\n    document.getElementById('health-form-timeout').value = timeout || 10000;\n    document.getElementById('health-form-codes').value = codes || '200';\n    document.getElementById('health-form-sla').value = sla || 99.9;\n    document.getElementById('health-form-slow').value = slow || 5000;\n    formEl.style.display = '';\n    addBtn.style.display = 'none';\n  }\n\n  function hideForm() {\n    formEl.style.display = 'none';\n    addBtn.style.display = '';\n    editingId = null;\n  }\n\n  addBtn?.addEventListener('click', () => showForm('', '', '', 10000, '200', 99.9, 5000));\n  formCancel?.addEventListener('click', hideForm);\n\n  formSave?.addEventListener('click', async () => {\n    const id = editingId || document.getElementById('health-form-id').value.trim();\n    if (!id) return showNotification('Service ID is required', 'warning');\n    const url = document.getElementById('health-form-url').value.trim();\n    if (!url) return showNotification('URL is required', 'warning');\n\n    const codes = document.getElementById('health-form-codes').value.split(',').map(c => parseInt(c.trim())).filter(Boolean);\n    const body = {\n      name: document.getElementById('health-form-name').value.trim() || id,\n      url,\n      timeout: parseInt(document.getElementById('health-form-timeout').value) || 10000,\n      expectedStatusCodes: codes.length ? codes : [200],\n      sla: { target: parseFloat(document.getElementById('health-form-sla').value) || 99.9 },\n      slowResponseThreshold: parseInt(document.getElementById('health-form-slow').value) || 5000\n    };\n\n    try {\n      formSave.textContent = 'Saving...';\n      formSave.disabled = true;\n      const res = await secureFetch(`/api/v1/health-checks/${encodeURIComponent(id)}/configure`, {\n        method: 'POST',\n        headers: { 'Content-Type': 'application/json' },\n        body: JSON.stringify(body)\n      });\n      const data = await res.json();\n      if (!data.success) throw new Error(data.error || 'Save failed');\n      hideForm();\n      loadConfig();\n      loadStatus();\n    } catch (e) {\n      showNotification('Error: ' + e.message, 'error');\n    } finally {\n      formSave.textContent = 'Save';\n      formSave.disabled = false;\n    }\n  });\n\n  document.addEventListener('health-edit', async (e) => {\n    const id = e.detail;\n    // Load existing config to populate form \u2014 use current status data as fallback\n    showForm(id, '', '', 10000, '200', 99.9, 5000);\n  });\n\n  document.addEventListener('health-delete', async (e) => {\n    const id = e.detail;\n    if (!confirm(`Delete health check for \"${id}\"?`)) return;\n    try {\n      const res = await secureFetch(`/api/v1/health-checks/${encodeURIComponent(id)}/configure`, { method: 'DELETE' });\n      const data = await res.json();\n      if (!data.success) throw new Error(data.error);\n      loadConfig();\n      loadStatus();\n    } catch (err) {\n      showNotification('Error: ' + err.message, 'error');\n    }\n  });\n\n  openBtn?.addEventListener('click', () => {\n    modal?.classList.add('show');\n    loadStatus();\n  });\n  wireModal(modal, cancelBtn);\n  refreshBtn?.addEventListener('click', loadStatus);\n\n  // Lazy-load tabs\n  document.querySelector('[data-panel=\"health-incidents\"]')?.addEventListener('click', loadIncidents);\n  document.querySelector('[data-panel=\"health-config\"]')?.addEventListener('click', loadConfig);\n})();\n;\n// ========== UPDATE MANAGEMENT ==========\n(function() {\n  // Inject modal HTML\n  injectModal('updates-modal', `<div id=\"updates-modal\" class=\"weather-modal\">\n    <div class=\"weather-modal-content\" style=\"min-width: 750px; max-width: 950px;\">\n      <h3>\u2B06\uFE0F Update Management</h3>\n      <p class=\"modal-subtitle\">\n        Check for container image updates, apply them, and manage rollbacks.\n      </p>\n\n      <div class=\"panel-tabs\">\n        <button class=\"panel-tab active\" data-panel=\"updates-available\">Available</button>\n        <button class=\"panel-tab\" data-panel=\"updates-history\">History</button>\n        <button class=\"panel-tab\" data-panel=\"updates-auto\">Auto-Update</button>\n        <button class=\"panel-tab\" data-panel=\"updates-dashcaddy\" id=\"updates-dashcaddy-tab\">DashCaddy</button>\n      </div>\n\n      <!-- Tab: Available Updates -->\n      <div id=\"updates-available\" class=\"panel-section active\">\n        <div style=\"margin-bottom: 12px; display: flex; gap: 8px; align-items: center;\">\n          <button id=\"updates-check-btn\" class=\"btn-accent-solid\">\uD83D\uDD0D Check for Updates</button>\n          <button id=\"updates-update-all-btn\" style=\"display: none; padding: 6px 14px; font-size: 0.82rem; background: #f97316; color: #fff; border: 1px solid #f97316; border-radius: 6px; cursor: pointer;\">\u2B06\uFE0F Update All</button>\n          <span id=\"updates-count-badge\" style=\"display: none; padding: 4px 10px; border-radius: 12px; font-size: 0.78rem; font-weight: 600; background: var(--accent); color: var(--bg);\"></span>\n        </div>\n        <div id=\"updates-available-container\" style=\"max-height: 450px; overflow-y: auto;\">\n          <div class=\"panel-empty\"><span class=\"empty-icon\">\uD83D\uDCE6</span> Click \"Check for Updates\" to scan containers.</div>\n        </div>\n      </div>\n\n      <!-- Tab: History -->\n      <div id=\"updates-history\" class=\"panel-section\">\n        <div id=\"updates-history-container\" class=\"scroll-container\">\n          <div class=\"panel-empty\"><span class=\"brand-spinner\"></span> Loading update history...</div>\n        </div>\n      </div>\n\n      <!-- Tab: Auto-Update -->\n      <div id=\"updates-auto\" class=\"panel-section\">\n        <div id=\"updates-auto-container\" class=\"scroll-container\">\n          <div class=\"panel-empty\"><span class=\"empty-icon\">\uD83E\uDD16</span> Loading auto-update configuration...</div>\n        </div>\n      </div>\n\n      <!-- Tab: DashCaddy Self-Update -->\n      <div id=\"updates-dashcaddy\" class=\"panel-section\">\n        <div id=\"dashcaddy-version-info\" style=\"display: flex; align-items: center; gap: 16px; margin-bottom: 16px; padding: 12px; border-radius: 8px; background: var(--bg);\">\n          <div style=\"flex: 1;\">\n            <div style=\"font-weight: 600; font-size: 1rem;\">DashCaddy</div>\n            <div id=\"dashcaddy-current-version\" style=\"color: var(--muted); font-size: 0.85rem;\">Loading...</div>\n          </div>\n          <div id=\"dashcaddy-update-badge\" style=\"display: none; padding: 4px 12px; border-radius: 12px; font-size: 0.78rem; font-weight: 600; background: var(--accent); color: var(--bg);\">Update available</div>\n        </div>\n        <div id=\"dashcaddy-update-details\" style=\"display: none; margin-bottom: 16px; padding: 12px; border-radius: 8px; border: 1px solid var(--border);\">\n          <div style=\"display: flex; justify-content: space-between; align-items: center; margin-bottom: 8px;\">\n            <span style=\"font-weight: 600;\">New version: <span id=\"dashcaddy-new-version\"></span></span>\n            <button id=\"dashcaddy-apply-btn\" class=\"btn-accent-solid\" style=\"padding: 6px 16px; font-size: 0.85rem;\">Update Now</button>\n          </div>\n          <div id=\"dashcaddy-changelog\" style=\"font-size: 0.8rem; color: var(--muted); max-height: 120px; overflow-y: auto; white-space: pre-wrap; font-family: var(--font-mono); line-height: 1.5;\"></div>\n        </div>\n        <div id=\"dashcaddy-status-bar\" style=\"display: none; margin-bottom: 16px; padding: 10px 12px; border-radius: 8px; font-size: 0.85rem;\"></div>\n        <div style=\"margin-bottom: 12px;\">\n          <button id=\"dashcaddy-check-btn\" style=\"padding: 6px 14px; font-size: 0.82rem;\">Check for Updates</button>\n          <button id=\"dashcaddy-rollback-btn\" style=\"padding: 6px 14px; font-size: 0.82rem; margin-left: 6px;\">Rollback</button>\n        </div>\n        <div id=\"dashcaddy-history-container\" style=\"max-height: 250px; overflow-y: auto;\">\n          <div class=\"panel-empty\"><span class=\"empty-icon\">\uD83D\uDCE6</span>No self-update history.</div>\n        </div>\n      </div>\n\n      <div class=\"panel-bottom-bar\">\n        <span id=\"updates-last-check\" class=\"text-auto-right\"></span>\n      </div>\n\n      <div class=\"weather-modal-buttons modal-footer-bar\">\n        <button id=\"updates-cancel\">Close</button>\n      </div>\n    </div>\n  </div>`);\n\n  const modal = document.getElementById('updates-modal');\n  const openBtn = document.getElementById('updates-btn');\n  const cancelBtn = document.getElementById('updates-cancel');\n  const checkBtn = document.getElementById('updates-check-btn');\n  const availableContainer = document.getElementById('updates-available-container');\n  const historyContainer = document.getElementById('updates-history-container');\n  const autoContainer = document.getElementById('updates-auto-container');\n  const lastCheckSpan = document.getElementById('updates-last-check');\n\n  async function loadAvailable() {\n    try {\n      const res = await fetch('/api/v1/updates/available');\n      const data = await res.json();\n      if (!data.success) throw new Error(data.error);\n\n      const updates = data.updates || [];\n      if (updates.length === 0) {\n        availableContainer.innerHTML = '<div class=\"panel-empty\"><span class=\"empty-icon\">\u2705</span>All containers are up to date.</div>';\n        lastCheckSpan.textContent = '';\n        document.getElementById('updates-update-all-btn').style.display = 'none';\n        document.getElementById('updates-count-badge').style.display = 'none';\n        window._pendingUpdates = [];\n        return;\n      }\n\n      let html = '<table style=\"width: 100%; border-collapse: collapse; font-size: 0.85rem;\">';\n      html += '<tr style=\"border-bottom: 1px solid var(--border); color: var(--muted);\"><th style=\"padding: 8px; text-align: left;\">Container</th><th style=\"padding: 8px; text-align: left;\">Image</th><th style=\"padding: 8px; text-align: left;\">Current</th><th style=\"padding: 8px; text-align: left;\">Latest</th><th style=\"padding: 8px; text-align: right;\">Actions</th></tr>';\n      for (const u of updates) {\n        // Match app by containerId first, then name\n        const appId = (() => {\n          const apps = window.APPS || [];\n          for (const a of apps) {\n            if (a.containerId === u.containerId || a.name === u.containerName || a.id === u.containerName) return a.id;\n          }\n          return u.containerName;\n        })();\n        html += `<tr data-app-id=\"${escapeHtml(appId)}\" style=\"border-bottom: 1px solid var(--border);\">`;\n        html += `<td style=\"padding: 8px; font-weight: 500;\">${escapeHtml(u.containerName)}</td>`;\n        html += `<td style=\"padding: 8px; color: var(--muted);\">${escapeHtml(u.imageName)}</td>`;\n        html += `<td style=\"padding: 8px;\"><code style=\"font-size: 0.78rem; background: var(--bg); padding: 2px 6px; border-radius: 4px;\">${escapeHtml(u.currentDigest)}</code></td>`;\n        html += `<td style=\"padding: 8px;\"><code style=\"font-size: 0.78rem; background: var(--ok-bg); color: var(--ok-fg); padding: 2px 6px; border-radius: 4px;\">${escapeHtml(u.latestDigest)}</code></td>`;\n        html += `<td style=\"padding: 8px; text-align: right;\">`;\n        html += `<button class=\"update-now-btn\" data-id=\"${escapeHtml(u.containerId)}\" data-name=\"${escapeHtml(u.containerName)}\" style=\"padding: 4px 10px; font-size: 0.78rem; background: var(--accent); color: var(--bg); border-color: var(--accent); margin-right: 4px;\">Update</button>`;\n        html += `<button class=\"rollback-btn\" data-id=\"${escapeHtml(u.containerId)}\" data-name=\"${escapeHtml(u.containerName)}\" style=\"padding: 4px 10px; font-size: 0.78rem;\">Rollback</button>`;\n        html += '</td></tr>';\n      }\n      html += '</table>';\n      availableContainer.innerHTML = html;\n      lastCheckSpan.textContent = updates.length + ' update(s) available';\n\n      // Show count badge and Update All button\n      const countBadge = document.getElementById('updates-count-badge');\n      const updateAllBtn = document.getElementById('updates-update-all-btn');\n      if (countBadge) {\n        countBadge.textContent = updates.length + ' pending';\n        countBadge.style.display = '';\n      }\n      if (updateAllBtn && updates.length > 0) {\n        updateAllBtn.style.display = '';\n      }\n\n      // Store updates for Update All button\n      window._pendingUpdates = updates;\n\n      // Wire update buttons\n      availableContainer.querySelectorAll('.update-now-btn').forEach(btn => {\n        btn.addEventListener('click', async () => {\n          const id = btn.dataset.id;\n          const name = btn.dataset.name;\n          if (!confirm(`Update \"${name}\" to the latest version? The container will restart.`)) return;\n          btn.textContent = 'Updating...';\n          btn.disabled = true;\n          try {\n            const r = await secureFetch(`/api/v1/updates/update/${encodeURIComponent(id)}`, {\n              method: 'POST',\n              headers: { 'Content-Type': 'application/json' },\n              body: JSON.stringify({ autoRollback: true })\n            });\n            const d = await r.json();\n            if (d.success) {\n              btn.textContent = 'Done!';\n              btn.style.background = 'var(--ok-fg)';\n              setTimeout(() => loadAvailable(), 2000);\n            } else {\n              throw new Error(d.error || 'Update failed');\n            }\n          } catch (e) {\n            btn.textContent = 'Failed';\n            btn.style.color = 'var(--bad-fg)';\n            showNotification('Update error: ' + e.message, 'error');\n            setTimeout(() => { btn.textContent = 'Update'; btn.disabled = false; btn.style.color = ''; btn.style.background = ''; }, 3000);\n          }\n        });\n      });\n\n      // Wire rollback buttons\n      availableContainer.querySelectorAll('.rollback-btn').forEach(btn => {\n        btn.addEventListener('click', async () => {\n          const id = btn.dataset.id;\n          const name = btn.dataset.name;\n          if (!confirm(`Rollback \"${name}\" to its previous version?`)) return;\n          btn.textContent = 'Rolling back...';\n          btn.disabled = true;\n          try {\n            const r = await secureFetch(`/api/v1/updates/rollback/${encodeURIComponent(id)}`, { method: 'POST' });\n            const d = await r.json();\n            if (d.success) {\n              btn.textContent = 'Rolled back!';\n              setTimeout(() => loadAvailable(), 2000);\n            } else {\n              throw new Error(d.error || 'Rollback failed');\n            }\n          } catch (e) {\n            btn.textContent = 'Failed';\n            showNotification('Rollback error: ' + e.message, 'error');\n            setTimeout(() => { btn.textContent = 'Rollback'; btn.disabled = false; }, 3000);\n          }\n        });\n      });\n    } catch (e) {\n      availableContainer.innerHTML = `<div class=\"panel-empty\" style=\"color: var(--bad-fg);\">Failed: ${escapeHtml(e.message)}</div>`;\n    }\n  }\n\n  // Update All \u2014 sequentially, skip failures\n  async function updateAllContainers() {\n    const updates = window._pendingUpdates || [];\n    if (!updates.length) return;\n    const btn = document.getElementById('updates-update-all-btn');\n    if (!confirm(`Update all ${updates.length} containers? Each will restart.`)) return;\n    btn.textContent = '\u23F3 Updating...';\n    btn.disabled = true;\n    let success = 0, failed = 0;\n    for (const u of updates) {\n      try {\n        const r = await secureFetch(`/api/v1/updates/update/${encodeURIComponent(u.containerId)}`, {\n          method: 'POST',\n          headers: { 'Content-Type': 'application/json' },\n          body: JSON.stringify({ autoRollback: true })\n        });\n        const d = await r.json();\n        if (d.success) success++;\n        else failed++;\n      } catch (_) { failed++; }\n    }\n    btn.textContent = `\u2705 Done`;\n    showNotification(`Update all: ${success} succeeded, ${failed} failed.`, success > 0 && failed === 0 ? 'success' : 'error');\n    setTimeout(() => {\n      btn.textContent = '\u2B06\uFE0F Update All';\n      btn.disabled = false;\n      loadAvailable();\n    }, 3000);\n  }\n\n  document.getElementById('updates-update-all-btn')?.addEventListener('click', updateAllContainers);\n\n  async function checkForUpdates() {\n    checkBtn.textContent = '\uD83D\uDD0D Checking...';\n    checkBtn.disabled = true;\n    try {\n      const res = await secureFetch('/api/v1/updates/check', { method: 'POST' });\n      const data = await res.json();\n      if (!data.success) throw new Error(data.error);\n      checkBtn.textContent = '\u2705 Done!';\n      await loadAvailable();\n    } catch (e) {\n      checkBtn.textContent = '\u274C Failed';\n      showNotification('Check error: ' + e.message, 'error');\n    }\n    setTimeout(() => { checkBtn.textContent = '\uD83D\uDD0D Check for Updates'; checkBtn.disabled = false; }, 3000);\n  }\n\n  async function loadHistory() {\n    try {\n      historyContainer.innerHTML = '<div class=\"panel-empty\"><span class=\"brand-spinner\"></span> Loading...</div>';\n      const res = await fetch('/api/v1/updates/history?limit=50');\n      const data = await res.json();\n      const history = data.success && data.history ? data.history : [];\n      if (history.length === 0) {\n        historyContainer.innerHTML = '<div class=\"panel-empty\"><span class=\"empty-icon\">\uD83D\uDCCB</span>No update history yet.</div>';\n        return;\n      }\n      let html = '<table style=\"width: 100%; border-collapse: collapse; font-size: 0.82rem;\">';\n      html += '<tr style=\"border-bottom: 1px solid var(--border); color: var(--muted);\"><th style=\"padding: 6px; text-align: left;\">When</th><th style=\"padding: 6px; text-align: left;\">Container</th><th style=\"padding: 6px; text-align: left;\">Image</th><th style=\"padding: 6px; text-align: left;\">Duration</th><th style=\"padding: 6px; text-align: left;\">Status</th></tr>';\n      for (const h of history) {\n        const ok = h.status === 'success';\n        const dur = h.duration ? (h.duration < 1000 ? h.duration + 'ms' : Math.round(h.duration / 1000) + 's') : '-';\n        html += `<tr style=\"border-bottom: 1px solid var(--border);\">`;\n        html += `<td style=\"padding: 6px; color: var(--muted);\">${timeAgo(h.timestamp)}</td>`;\n        html += `<td style=\"padding: 6px; font-weight: 500;\">${escapeHtml(h.containerName)}</td>`;\n        html += `<td style=\"padding: 6px; color: var(--muted);\">${escapeHtml(h.imageName)}</td>`;\n        html += `<td style=\"padding: 6px;\">${dur}</td>`;\n        html += `<td style=\"padding: 6px;\"><span style=\"color: ${ok ? 'var(--ok-fg)' : 'var(--bad-fg)'};\">${ok ? '\u2713 success' : '\u2717 failed'}</span></td>`;\n        html += '</tr>';\n        if (!ok && h.error) {\n          html += `<tr><td colspan=\"5\" style=\"padding: 4px 6px 8px; font-size: 0.78rem; color: var(--bad-fg);\">${escapeHtml(h.error)}</td></tr>`;\n        }\n      }\n      html += '</table>';\n      historyContainer.innerHTML = html;\n    } catch (e) {\n      historyContainer.innerHTML = `<div class=\"panel-empty\" style=\"color: var(--bad-fg);\">Failed: ${escapeHtml(e.message)}</div>`;\n    }\n  }\n\n  async function loadAutoConfig() {\n    try {\n      autoContainer.innerHTML = '<div class=\"panel-empty\"><span class=\"brand-spinner\"></span> Loading...</div>';\n\n      // Fetch containers and saved auto-update config in parallel\n      const [containersRes, configRes] = await Promise.all([\n        fetch('/api/v1/stats/containers'),\n        fetch('/api/v1/updates/auto-update')\n      ]);\n      const containersData = await containersRes.json();\n      const configData = await configRes.json();\n\n      const containers = containersData.success && containersData.stats ? containersData.stats : [];\n      const savedConfig = configData.success && configData.config ? configData.config : {};\n\n      if (containers.length === 0) {\n        autoContainer.innerHTML = '<div class=\"panel-empty\"><span class=\"empty-icon\">\uD83E\uDD16</span>No running containers found.</div>';\n        return;\n      }\n\n      let html = '<div style=\"margin-bottom: 12px; font-size: 0.8rem; color: var(--muted);\">Auto-updates run during maintenance window (default 2AM-4AM). Daily = every day, Weekly = Sundays, Monthly = 1st of month.</div>';\n      html += '<table style=\"width: 100%; border-collapse: collapse; font-size: 0.85rem;\">';\n      html += '<tr style=\"border-bottom: 1px solid var(--border); color: var(--muted);\"><th style=\"padding: 8px; text-align: left;\">Container</th><th style=\"padding: 8px; text-align: left;\">Schedule</th><th style=\"padding: 8px; text-align: left;\">Window</th><th style=\"padding: 8px; text-align: left;\">Rollback</th><th style=\"padding: 8px; text-align: left;\">Last Run</th><th style=\"padding: 8px; text-align: right;\">Actions</th></tr>';\n      for (const c of containers) {\n        const name = c.name || c.Names?.[0]?.replace(/^\\//, '') || c.Id?.substring(0, 12);\n        const cid = c.containerId || c.Id;\n        const saved = savedConfig[cid] || {};\n        const scheduleVal = saved.enabled ? (saved.schedule || 'weekly') : '';\n        const rollbackVal = saved.autoRollback !== false;\n        const windowVal = saved.maintenanceWindow || '';\n        const lastRun = saved.lastAutoUpdate ? timeAgo(saved.lastAutoUpdate) : 'Never';\n\n        html += `<tr style=\"border-bottom: 1px solid var(--border);\" data-container-id=\"${escapeHtml(cid)}\">`;\n        html += `<td style=\"padding: 8px; font-weight: 500;\">${escapeHtml(name)}</td>`;\n        html += `<td style=\"padding: 8px;\">\n          <select class=\"auto-schedule\" data-id=\"${escapeHtml(cid)}\" style=\"padding: 4px 8px; border-radius: 4px; border: 1px solid var(--border); background: var(--bg); color: var(--fg); font-size: 0.82rem;\">\n            <option value=\"\"${!scheduleVal ? ' selected' : ''}>Disabled</option>\n            <option value=\"daily\"${scheduleVal === 'daily' ? ' selected' : ''}>Daily</option>\n            <option value=\"weekly\"${scheduleVal === 'weekly' ? ' selected' : ''}>Weekly</option>\n            <option value=\"monthly\"${scheduleVal === 'monthly' ? ' selected' : ''}>Monthly</option>\n          </select></td>`;\n        html += `<td style=\"padding: 8px;\"><input type=\"text\" class=\"auto-window\" data-id=\"${escapeHtml(cid)}\" value=\"${escapeHtml(windowVal)}\" placeholder=\"02:00-04:00\" style=\"width: 90px; padding: 3px 6px; font-size: 0.78rem; border: 1px solid var(--border); border-radius: 4px; background: var(--bg); color: var(--fg);\" /></td>`;\n        html += `<td style=\"padding: 8px;\"><input type=\"checkbox\" class=\"auto-rollback\" data-id=\"${escapeHtml(cid)}\"${rollbackVal ? ' checked' : ''} /></td>`;\n        html += `<td style=\"padding: 8px; font-size: 0.78rem; color: var(--muted);\">${lastRun}</td>`;\n        html += `<td style=\"padding: 8px; text-align: right;\"><button class=\"save-auto-btn\" data-id=\"${escapeHtml(cid)}\" data-name=\"${escapeHtml(name)}\" style=\"padding: 4px 10px; font-size: 0.78rem;\">Save</button></td>`;\n        html += '</tr>';\n      }\n      html += '</table>';\n      autoContainer.innerHTML = html;\n\n      // Wire save buttons\n      autoContainer.querySelectorAll('.save-auto-btn').forEach(btn => {\n        btn.addEventListener('click', async () => {\n          const id = btn.dataset.id;\n          const row = btn.closest('tr');\n          const schedule = row.querySelector('.auto-schedule').value;\n          const rollback = row.querySelector('.auto-rollback').checked;\n          const window = row.querySelector('.auto-window').value.trim();\n          btn.textContent = 'Saving...';\n          btn.disabled = true;\n          try {\n            const r = await secureFetch(`/api/v1/updates/auto-update/${encodeURIComponent(id)}`, {\n              method: 'POST',\n              headers: { 'Content-Type': 'application/json' },\n              body: JSON.stringify({ enabled: !!schedule, schedule: schedule || 'weekly', autoRollback: rollback, maintenanceWindow: window || undefined })\n            });\n            const d = await r.json();\n            if (d.success) {\n              btn.textContent = '\u2713 Saved';\n            } else {\n              throw new Error(d.error);\n            }\n          } catch (e) {\n            btn.textContent = '\u2717 Error';\n            showNotification('Save error: ' + e.message, 'error');\n          }\n          setTimeout(() => { btn.textContent = 'Save'; btn.disabled = false; }, 2000);\n        });\n      });\n    } catch (e) {\n      autoContainer.innerHTML = `<div class=\"panel-empty\" style=\"color: var(--bad-fg);\">Failed: ${escapeHtml(e.message)}</div>`;\n    }\n  }\n\n  // ===== DASHCADDY SELF-UPDATE =====\n\n  const dcVersionInfo = document.getElementById('dashcaddy-current-version');\n  const dcUpdateBadge = document.getElementById('dashcaddy-update-badge');\n  const dcUpdateDetails = document.getElementById('dashcaddy-update-details');\n  const dcNewVersion = document.getElementById('dashcaddy-new-version');\n  const dcChangelog = document.getElementById('dashcaddy-changelog');\n  const dcApplyBtn = document.getElementById('dashcaddy-apply-btn');\n  const dcCheckBtn = document.getElementById('dashcaddy-check-btn');\n  const dcRollbackBtn = document.getElementById('dashcaddy-rollback-btn');\n  const dcStatusBar = document.getElementById('dashcaddy-status-bar');\n  const dcHistoryContainer = document.getElementById('dashcaddy-history-container');\n\n  let dcLastCheck = null;\n\n  function dcShowStatus(msg, type) {\n    if (!dcStatusBar) return;\n    dcStatusBar.style.display = 'block';\n    dcStatusBar.style.background = type === 'error' ? 'var(--bad-bg)' : type === 'success' ? 'var(--ok-bg)' : 'var(--bg)';\n    dcStatusBar.style.color = type === 'error' ? 'var(--bad-fg)' : type === 'success' ? 'var(--ok-fg)' : 'var(--fg)';\n    dcStatusBar.textContent = msg;\n  }\n\n  async function dcLoadVersion() {\n    try {\n      const res = await fetch('/api/v1/system/version');\n      const data = await res.json();\n      if (data.success) {\n        const commit = data.commit && data.commit !== 'unknown' ? data.commit : null;\n        dcVersionInfo.textContent = 'v' + data.version + (commit ? ' (' + commit.substring(0, 7) + ')' : '');\n      }\n    } catch (_) {\n      dcVersionInfo.textContent = 'Unable to fetch version';\n    }\n  }\n\n  async function dcCheckForUpdate(silent) {\n    if (!silent) {\n      dcCheckBtn.textContent = 'Checking...';\n      dcCheckBtn.disabled = true;\n    }\n    try {\n      const res = await fetch('/api/v1/system/update-check');\n      const data = await res.json();\n      dcLastCheck = data;\n\n      if (data.success && data.available && data.remote) {\n        dcUpdateBadge.style.display = '';\n        dcUpdateDetails.style.display = '';\n        dcNewVersion.textContent = 'v' + data.remote.version;\n        dcChangelog.textContent = data.remote.changelog || 'No changelog available.';\n\n        // Add notification dot to the Updates button\n        const updatesBtn = document.getElementById('updates-btn');\n        if (updatesBtn && !updatesBtn.querySelector('.update-dot')) {\n          const dot = document.createElement('span');\n          dot.className = 'update-dot';\n          dot.style.cssText = 'position:absolute;top:2px;right:2px;width:8px;height:8px;border-radius:50%;background:var(--accent);';\n          updatesBtn.style.position = 'relative';\n          updatesBtn.appendChild(dot);\n        }\n        // Also add dot to the DashCaddy tab\n        const dcTab = document.getElementById('updates-dashcaddy-tab');\n        if (dcTab && !dcTab.querySelector('.update-dot')) {\n          const dot = document.createElement('span');\n          dot.className = 'update-dot';\n          dot.style.cssText = 'display:inline-block;width:6px;height:6px;border-radius:50%;background:var(--accent);margin-left:4px;vertical-align:middle;';\n          dcTab.appendChild(dot);\n        }\n      } else {\n        dcUpdateBadge.style.display = 'none';\n        dcUpdateDetails.style.display = 'none';\n        await dcLoadVersion();\n        if (!silent) dcShowStatus('You are running the latest version.', 'success');\n      }\n\n      if (!silent) {\n        dcCheckBtn.textContent = 'Check for Updates';\n        dcCheckBtn.disabled = false;\n      }\n    } catch (e) {\n      if (!silent) {\n        dcShowStatus('Failed to check: ' + e.message, 'error');\n        dcCheckBtn.textContent = 'Check for Updates';\n        dcCheckBtn.disabled = false;\n      }\n    }\n  }\n\n  async function dcApplyUpdate() {\n    if (!confirm('Apply DashCaddy update? The API container will restart.')) return false;\n    dcApplyBtn.textContent = 'Updating...';\n    dcApplyBtn.disabled = true;\n    dcShowStatus('Downloading and applying update...', 'info');\n    try {\n      const res = await secureFetch('/api/v1/system/update-apply', { method: 'POST' });\n      const data = await res.json();\n      if (data.success) {\n        dcShowStatus('Update initiated: v' + (data.fromVersion || '?') + ' \u2192 v' + (data.toVersion || '?') + '. The container will restart shortly.', 'success');\n        dcApplyBtn.textContent = 'Applied!';\n        // Remove notification dots\n        document.querySelectorAll('.update-dot').forEach(d => d.remove());\n        return true;\n      } else {\n        throw new Error(data.error || 'Update failed');\n      }\n    } catch (e) {\n      dcShowStatus('Update failed: ' + e.message, 'error');\n      dcApplyBtn.textContent = 'Update Now';\n      dcApplyBtn.disabled = false;\n      throw e;\n    }\n  }\n\n  async function dcLoadHistory() {\n    try {\n      const res = await fetch('/api/v1/system/update-history');\n      const data = await res.json();\n      const history = data.success && data.history ? data.history : [];\n      if (history.length === 0) {\n        dcHistoryContainer.innerHTML = '<div class=\"panel-empty\"><span class=\"empty-icon\">\uD83D\uDCE6</span>No self-update history.</div>';\n        return;\n      }\n      let html = '<table style=\"width: 100%; border-collapse: collapse; font-size: 0.82rem;\">';\n      html += '<tr style=\"border-bottom: 1px solid var(--border); color: var(--muted);\"><th style=\"padding: 6px; text-align: left;\">When</th><th style=\"padding: 6px; text-align: left;\">Version</th><th style=\"padding: 6px; text-align: left;\">From</th><th style=\"padding: 6px; text-align: left;\">Status</th></tr>';\n      for (const h of history) {\n        const st = h.status === 'success' ? '\u2713 success' : h.status === 'pending' ? '\u23F3 pending' : h.status === 'partial' ? '\u26A0 partial' : '\u2717 ' + h.status;\n        const stColor = h.status === 'success' ? 'var(--ok-fg)' : h.status === 'pending' ? 'var(--muted)' : 'var(--bad-fg)';\n        html += '<tr style=\"border-bottom: 1px solid var(--border);\">';\n        html += '<td style=\"padding: 6px; color: var(--muted);\">' + timeAgo(h.timestamp) + '</td>';\n        html += '<td style=\"padding: 6px; font-weight: 500;\">v' + escapeHtml(h.version) + (h.rollback ? ' (rollback)' : '') + '</td>';\n        html += '<td style=\"padding: 6px; color: var(--muted);\">v' + escapeHtml(h.fromVersion || '?') + '</td>';\n        html += '<td style=\"padding: 6px;\"><span style=\"color: ' + stColor + ';\">' + st + '</span></td>';\n        html += '</tr>';\n        if (h.error) {\n          html += '<tr><td colspan=\"4\" style=\"padding: 4px 6px 8px; font-size: 0.78rem; color: var(--bad-fg);\">' + escapeHtml(h.error) + '</td></tr>';\n        }\n        if (h.note) {\n          html += '<tr><td colspan=\"4\" style=\"padding: 4px 6px 8px; font-size: 0.78rem; color: var(--muted);\">' + escapeHtml(h.note) + '</td></tr>';\n        }\n      }\n      html += '</table>';\n      dcHistoryContainer.innerHTML = html;\n    } catch (e) {\n      dcHistoryContainer.innerHTML = '<div class=\"panel-empty\" style=\"color: var(--bad-fg);\">Failed: ' + escapeHtml(e.message) + '</div>';\n    }\n  }\n\n  async function dcShowRollback() {\n    try {\n      const res = await fetch('/api/v1/system/rollback-versions');\n      const data = await res.json();\n      const versions = data.success && data.versions ? data.versions : [];\n      if (versions.length === 0) {\n        showNotification('No rollback versions available.', 'info');\n        return;\n      }\n      const version = prompt('Available rollback versions:\\n' + versions.join('\\n') + '\\n\\nEnter version to rollback to:');\n      if (!version) return;\n      if (!versions.includes(version)) {\n        showNotification('Invalid version: ' + version, 'error');\n        return;\n      }\n      if (!confirm('Rollback DashCaddy to v' + version + '? The container will restart.')) return;\n      dcShowStatus('Rolling back to v' + version + '...', 'info');\n      const r = await secureFetch('/api/v1/system/rollback', {\n        method: 'POST',\n        headers: { 'Content-Type': 'application/json' },\n        body: JSON.stringify({ version })\n      });\n      const d = await r.json();\n      if (d.success) {\n        dcShowStatus('Rollback to v' + version + ' initiated. Container will restart.', 'success');\n      } else {\n        throw new Error(d.error || 'Rollback failed');\n      }\n    } catch (e) {\n      dcShowStatus('Rollback failed: ' + e.message, 'error');\n    }\n  }\n\n  dcCheckBtn?.addEventListener('click', () => dcCheckForUpdate(false));\n  dcApplyBtn?.addEventListener('click', () => dcApplyUpdate().catch(() => {}));\n  dcRollbackBtn?.addEventListener('click', dcShowRollback);\n\n  checkBtn?.addEventListener('click', checkForUpdates);\n  openBtn?.addEventListener('click', () => {\n    modal?.classList.add('show');\n    loadAvailable();\n  });\n  wireModal(modal, cancelBtn);\n\n  // Open Update Management modal, optionally scrolled to a specific app\n  window.openUpdateModal = function(appId) {\n    modal?.classList.add('show');\n    loadAvailable().then(() => {\n      if (!appId) return;\n      // Scroll to and highlight the matching row\n      const row = availableContainer.querySelector(`[data-app-id=\"${appId}\"]`);\n      if (row) {\n        row.scrollIntoView({ behavior: 'smooth', block: 'center' });\n        row.style.background = 'rgba(249,115,22,0.15)';\n        setTimeout(() => { row.style.background = ''; }, 3000);\n      }\n    });\n  };\n\n  // Lazy-load tabs\n  document.querySelector('[data-panel=\"updates-history\"]')?.addEventListener('click', loadHistory);\n  document.querySelector('[data-panel=\"updates-auto\"]')?.addEventListener('click', loadAutoConfig);\n  document.querySelector('[data-panel=\"updates-dashcaddy\"]')?.addEventListener('click', () => {\n    dcLoadVersion();\n    dcLoadHistory();\n    if (!dcLastCheck) dcCheckForUpdate(true);\n  });\n\n  window.dcApplyUpdate = dcApplyUpdate;\n  window.dcCheckForUpdate = dcCheckForUpdate;\n\n  // Non-blocking check on page load \u2014 just adds notification dot if update available\n  setTimeout(() => dcCheckForUpdate(true), 5000);\n})();\n;\n// ========== DOCKER RESOURCES (Volumes, Networks, Disk Usage) ==========\n(function() {\n  injectModal('docker-resources-modal', `<div id=\"docker-resources-modal\" class=\"weather-modal\">\n    <div class=\"weather-modal-content\" style=\"min-width: 750px; max-width: 950px;\">\n      <h3>\uD83D\uDC33 Docker Resources</h3>\n      <p class=\"modal-subtitle\">Manage volumes, networks, and view disk usage.</p>\n\n      <div class=\"panel-tabs\">\n        <button class=\"panel-tab active\" data-panel=\"dr-volumes\">Volumes</button>\n        <button class=\"panel-tab\" data-panel=\"dr-networks\">Networks</button>\n        <button class=\"panel-tab\" data-panel=\"dr-disk\">Disk Usage</button>\n      </div>\n\n      <!-- Volumes -->\n      <div id=\"dr-volumes\" class=\"panel-section active\">\n        <div style=\"display: flex; gap: 8px; margin-bottom: 12px;\">\n          <input type=\"text\" id=\"dr-vol-name\" placeholder=\"Volume name\" style=\"flex: 1; padding: 6px 10px; border: 1px solid var(--border); border-radius: 6px; background: var(--bg); color: var(--fg);\" />\n          <button id=\"dr-vol-create\" class=\"btn-accent-solid\" style=\"padding: 6px 14px; font-size: 0.82rem;\">Create</button>\n        </div>\n        <div id=\"dr-vol-list\" class=\"scroll-container\" style=\"max-height: 400px;\">\n          <div class=\"panel-empty\"><span class=\"brand-spinner\"></span> Loading...</div>\n        </div>\n      </div>\n\n      <!-- Networks -->\n      <div id=\"dr-networks\" class=\"panel-section\">\n        <div style=\"display: flex; gap: 8px; margin-bottom: 12px;\">\n          <input type=\"text\" id=\"dr-net-name\" placeholder=\"Network name\" style=\"flex: 1; padding: 6px 10px; border: 1px solid var(--border); border-radius: 6px; background: var(--bg); color: var(--fg);\" />\n          <select id=\"dr-net-driver\" style=\"padding: 6px 10px; border: 1px solid var(--border); border-radius: 6px; background: var(--bg); color: var(--fg);\">\n            <option value=\"bridge\">bridge</option>\n            <option value=\"overlay\">overlay</option>\n            <option value=\"host\">host</option>\n          </select>\n          <button id=\"dr-net-create\" class=\"btn-accent-solid\" style=\"padding: 6px 14px; font-size: 0.82rem;\">Create</button>\n        </div>\n        <div id=\"dr-net-list\" class=\"scroll-container\" style=\"max-height: 400px;\">\n          <div class=\"panel-empty\"><span class=\"brand-spinner\"></span> Loading...</div>\n        </div>\n      </div>\n\n      <!-- Disk Usage -->\n      <div id=\"dr-disk\" class=\"panel-section\">\n        <div id=\"dr-disk-content\">\n          <div class=\"panel-empty\"><span class=\"brand-spinner\"></span> Loading...</div>\n        </div>\n      </div>\n\n      <div class=\"weather-modal-buttons modal-footer-bar\">\n        <button id=\"dr-close\">Close</button>\n      </div>\n    </div>\n  </div>`);\n\n  const modal = document.getElementById('docker-resources-modal');\n  const openBtn = document.getElementById('docker-resources-btn');\n  const closeBtn = document.getElementById('dr-close');\n\n  function fmtBytes(bytes) {\n    if (!bytes || bytes === 0) return '0 B';\n    const units = ['B', 'KB', 'MB', 'GB', 'TB'];\n    const i = Math.floor(Math.log(Math.abs(bytes)) / Math.log(1024));\n    return (bytes / Math.pow(1024, i)).toFixed(1) + ' ' + units[i];\n  }\n\n  // ===== VOLUMES =====\n  async function loadVolumes() {\n    const container = document.getElementById('dr-vol-list');\n    try {\n      const data = await getJSON('/api/v1/docker/volumes');\n      const vols = data.volumes || [];\n      if (vols.length === 0) {\n        container.innerHTML = '<div class=\"panel-empty\"><span class=\"empty-icon\">\uD83D\uDCE6</span>No volumes found.</div>';\n        return;\n      }\n      let html = '<table style=\"width: 100%; border-collapse: collapse; font-size: 0.82rem;\">';\n      html += '<tr style=\"border-bottom: 1px solid var(--border); color: var(--muted);\"><th style=\"padding: 6px; text-align: left;\">Name</th><th style=\"padding: 6px;\">Driver</th><th style=\"padding: 6px;\">Scope</th><th style=\"padding: 6px; text-align: right;\">Actions</th></tr>';\n      for (const v of vols) {\n        const isSystem = v.name === 'buildkit' || v.name.length === 64;\n        html += `<tr style=\"border-bottom: 1px solid var(--border);\">`;\n        html += `<td style=\"padding: 6px; font-weight: 500; max-width: 300px; overflow: hidden; text-overflow: ellipsis; white-space: nowrap;\" title=\"${escapeHtml(v.name)}\">${escapeHtml(v.name.length > 40 ? v.name.substring(0, 37) + '...' : v.name)}</td>`;\n        html += `<td style=\"padding: 6px; text-align: center; color: var(--muted);\">${escapeHtml(v.driver)}</td>`;\n        html += `<td style=\"padding: 6px; text-align: center; color: var(--muted);\">${escapeHtml(v.scope)}</td>`;\n        html += `<td style=\"padding: 6px; text-align: right;\">`;\n        if (!isSystem) {\n          html += `<button class=\"dr-vol-del\" data-name=\"${escapeHtml(v.name)}\" style=\"padding: 3px 8px; font-size: 0.75rem; color: var(--bad-fg);\">Delete</button>`;\n        }\n        html += `</td></tr>`;\n      }\n      html += '</table>';\n      container.innerHTML = html;\n\n      container.querySelectorAll('.dr-vol-del').forEach(btn => {\n        btn.addEventListener('click', async () => {\n          if (!confirm(`Delete volume \"${btn.dataset.name}\"? Data will be lost.`)) return;\n          btn.textContent = '...';\n          btn.disabled = true;\n          try {\n            await deleteAPI(`/api/v1/docker/volumes/${encodeURIComponent(btn.dataset.name)}?force=true`);\n            loadVolumes();\n          } catch (e) {\n            showNotification('Delete failed: ' + e.message, 'error');\n            btn.textContent = 'Delete';\n            btn.disabled = false;\n          }\n        });\n      });\n    } catch (e) {\n      container.innerHTML = `<div class=\"panel-empty\" style=\"color: var(--bad-fg);\">Failed: ${escapeHtml(e.message)}</div>`;\n    }\n  }\n\n  document.getElementById('dr-vol-create')?.addEventListener('click', async () => {\n    const nameInput = document.getElementById('dr-vol-name');\n    const name = nameInput.value.trim();\n    if (!name) { showNotification('Enter a volume name', 'warning'); return; }\n    try {\n      await postJSON('/api/v1/docker/volumes', { name });\n      nameInput.value = '';\n      showNotification(`Volume \"${name}\" created`, 'success');\n      loadVolumes();\n    } catch (e) {\n      showNotification('Create failed: ' + e.message, 'error');\n    }\n  });\n\n  // ===== NETWORKS =====\n  async function loadNetworks() {\n    const container = document.getElementById('dr-net-list');\n    try {\n      const data = await getJSON('/api/v1/docker/networks');\n      const nets = data.networks || [];\n      if (nets.length === 0) {\n        container.innerHTML = '<div class=\"panel-empty\"><span class=\"empty-icon\">\uD83C\uDF10</span>No networks found.</div>';\n        return;\n      }\n      let html = '<table style=\"width: 100%; border-collapse: collapse; font-size: 0.82rem;\">';\n      html += '<tr style=\"border-bottom: 1px solid var(--border); color: var(--muted);\"><th style=\"padding: 6px; text-align: left;\">Name</th><th style=\"padding: 6px;\">Driver</th><th style=\"padding: 6px;\">Scope</th><th style=\"padding: 6px;\">Containers</th><th style=\"padding: 6px; text-align: right;\">Actions</th></tr>';\n      for (const n of nets) {\n        const isSystem = ['bridge', 'host', 'none'].includes(n.name);\n        html += `<tr style=\"border-bottom: 1px solid var(--border);\">`;\n        html += `<td style=\"padding: 6px; font-weight: 500;\">${escapeHtml(n.name)}</td>`;\n        html += `<td style=\"padding: 6px; text-align: center; color: var(--muted);\">${escapeHtml(n.driver)}</td>`;\n        html += `<td style=\"padding: 6px; text-align: center; color: var(--muted);\">${escapeHtml(n.scope)}</td>`;\n        html += `<td style=\"padding: 6px; text-align: center;\">${n.containers}</td>`;\n        html += `<td style=\"padding: 6px; text-align: right;\">`;\n        if (!isSystem) {\n          html += `<button class=\"dr-net-del\" data-id=\"${escapeHtml(n.id)}\" data-name=\"${escapeHtml(n.name)}\" style=\"padding: 3px 8px; font-size: 0.75rem; color: var(--bad-fg);\">Delete</button>`;\n        }\n        html += `</td></tr>`;\n      }\n      html += '</table>';\n      container.innerHTML = html;\n\n      container.querySelectorAll('.dr-net-del').forEach(btn => {\n        btn.addEventListener('click', async () => {\n          if (!confirm(`Delete network \"${btn.dataset.name}\"?`)) return;\n          btn.textContent = '...';\n          btn.disabled = true;\n          try {\n            await deleteAPI(`/api/v1/docker/networks/${encodeURIComponent(btn.dataset.id)}`);\n            loadNetworks();\n          } catch (e) {\n            showNotification('Delete failed: ' + e.message, 'error');\n            btn.textContent = 'Delete';\n            btn.disabled = false;\n          }\n        });\n      });\n    } catch (e) {\n      container.innerHTML = `<div class=\"panel-empty\" style=\"color: var(--bad-fg);\">Failed: ${escapeHtml(e.message)}</div>`;\n    }\n  }\n\n  document.getElementById('dr-net-create')?.addEventListener('click', async () => {\n    const nameInput = document.getElementById('dr-net-name');\n    const driverSelect = document.getElementById('dr-net-driver');\n    const name = nameInput.value.trim();\n    if (!name) { showNotification('Enter a network name', 'warning'); return; }\n    try {\n      await postJSON('/api/v1/docker/networks', { name, driver: driverSelect.value });\n      nameInput.value = '';\n      showNotification(`Network \"${name}\" created`, 'success');\n      loadNetworks();\n    } catch (e) {\n      showNotification('Create failed: ' + e.message, 'error');\n    }\n  });\n\n  // ===== DISK USAGE =====\n  async function loadDiskUsage() {\n    const container = document.getElementById('dr-disk-content');\n    try {\n      const data = await getJSON('/api/v1/docker/disk-usage');\n      const sections = [\n        { label: 'Images', icon: '\uD83D\uDCC0', count: data.images.count, size: data.images.size, reclaimable: data.images.reclaimable },\n        { label: 'Containers', icon: '\uD83D\uDCE6', count: data.containers.count, size: data.containers.size, extra: `${data.containers.running} running` },\n        { label: 'Volumes', icon: '\uD83D\uDCBE', count: data.volumes.count, size: data.volumes.size, reclaimable: data.volumes.reclaimable },\n        { label: 'Build Cache', icon: '\uD83D\uDD27', count: data.buildCache.count, size: data.buildCache.size, reclaimable: data.buildCache.reclaimable },\n      ];\n\n      let html = `<div style=\"font-size: 1.1rem; font-weight: 600; margin-bottom: 16px;\">Total: ${fmtBytes(data.totalSize)}</div>`;\n      html += '<div style=\"display: grid; grid-template-columns: 1fr 1fr; gap: 12px;\">';\n      for (const s of sections) {\n        html += `<div style=\"padding: 14px; background: var(--bg); border-radius: 8px; border: 1px solid var(--border);\">`;\n        html += `<div style=\"font-weight: 600; margin-bottom: 6px;\">${s.icon} ${s.label} <span style=\"color: var(--muted); font-weight: 400; font-size: 0.82rem;\">(${s.count})</span></div>`;\n        html += `<div style=\"font-size: 1.1rem; font-weight: 600; color: var(--accent);\">${fmtBytes(s.size)}</div>`;\n        if (s.reclaimable > 0) html += `<div style=\"font-size: 0.78rem; color: var(--muted);\">Reclaimable: ${fmtBytes(s.reclaimable)}</div>`;\n        if (s.extra) html += `<div style=\"font-size: 0.78rem; color: var(--muted);\">${s.extra}</div>`;\n        html += '</div>';\n      }\n      html += '</div>';\n      container.innerHTML = html;\n    } catch (e) {\n      container.innerHTML = `<div class=\"panel-empty\" style=\"color: var(--bad-fg);\">Failed: ${escapeHtml(e.message)}</div>`;\n    }\n  }\n\n  // Modal events\n  openBtn?.addEventListener('click', () => {\n    modal?.classList.add('show');\n    loadVolumes();\n  });\n  wireModal(modal, closeBtn);\n\n  // Lazy-load tabs\n  document.querySelector('[data-panel=\"dr-networks\"]')?.addEventListener('click', loadNetworks);\n  document.querySelector('[data-panel=\"dr-disk\"]')?.addEventListener('click', loadDiskUsage);\n})();\n;\n// ========== DOCKER COMPOSE IMPORT ==========\n(function() {\n  injectModal('compose-import-modal', `<div id=\"compose-import-modal\" class=\"weather-modal\">\n    <div class=\"weather-modal-content\" style=\"min-width: 650px; max-width: 800px;\">\n      <h3>\uD83D\uDCE6 Import Docker Compose</h3>\n      <p class=\"modal-subtitle\">Paste a docker-compose.yml to import and deploy services.</p>\n\n      <!-- Step 1: Paste YAML -->\n      <div id=\"compose-step-paste\">\n        <div style=\"margin-bottom: 12px;\">\n          <label class=\"form-label-accent-sm\">Stack Name</label>\n          <input type=\"text\" id=\"compose-stack-name\" placeholder=\"my-stack\" value=\"\" style=\"width: 100%; padding: 8px 10px; border: 1px solid var(--border); border-radius: 6px; background: var(--bg); color: var(--fg);\" />\n        </div>\n        <div style=\"margin-bottom: 12px;\">\n          <label class=\"form-label-accent-sm\">docker-compose.yml</label>\n          <textarea id=\"compose-yaml\" rows=\"14\" placeholder=\"version: '3'&#10;services:&#10;  web:&#10;    image: nginx:latest&#10;    ports:&#10;      - '8080:80'\" style=\"width: 100%; padding: 10px; font-family: monospace; font-size: 0.82rem; border: 1px solid var(--border); border-radius: 6px; background: var(--bg); color: var(--fg); resize: vertical;\"></textarea>\n          <div style=\"margin-top: 6px;\">\n            <label style=\"display: inline-flex; align-items: center; gap: 6px; cursor: pointer; font-size: 0.82rem; color: var(--muted);\">\n              <input type=\"file\" id=\"compose-file-upload\" accept=\".yml,.yaml\" style=\"display: none;\" />\n              <span style=\"text-decoration: underline;\">or upload a file</span>\n            </label>\n          </div>\n        </div>\n        <div class=\"weather-modal-buttons modal-footer-bar\">\n          <button id=\"compose-parse-btn\" class=\"btn-accent-solid\" style=\"padding: 8px 20px;\">Parse & Preview</button>\n          <button id=\"compose-cancel\">Cancel</button>\n        </div>\n      </div>\n\n      <!-- Step 2: Preview -->\n      <div id=\"compose-step-preview\" style=\"display: none;\">\n        <div id=\"compose-preview-content\"></div>\n        <div class=\"weather-modal-buttons modal-footer-bar\" style=\"margin-top: 16px;\">\n          <button id=\"compose-deploy-btn\" class=\"btn-accent-solid\" style=\"padding: 8px 20px;\">Deploy All</button>\n          <button id=\"compose-back-btn\">Back</button>\n        </div>\n      </div>\n\n      <!-- Step 3: Progress -->\n      <div id=\"compose-step-progress\" style=\"display: none;\">\n        <div id=\"compose-progress-content\"></div>\n      </div>\n    </div>\n  </div>`);\n\n  const modal = document.getElementById('compose-import-modal');\n  const openBtn = document.getElementById('compose-import-btn');\n  const cancelBtn = document.getElementById('compose-cancel');\n\n  wireModal(modal, cancelBtn);\n\n  let parsedData = null;\n\n  function showStep(step) {\n    document.getElementById('compose-step-paste').style.display = step === 'paste' ? '' : 'none';\n    document.getElementById('compose-step-preview').style.display = step === 'preview' ? '' : 'none';\n    document.getElementById('compose-step-progress').style.display = step === 'progress' ? '' : 'none';\n  }\n\n  openBtn?.addEventListener('click', () => {\n    showStep('paste');\n    parsedData = null;\n    document.getElementById('compose-yaml').value = '';\n    document.getElementById('compose-stack-name').value = '';\n    modal?.classList.add('show');\n  });\n\n  // File upload\n  document.getElementById('compose-file-upload')?.addEventListener('change', (e) => {\n    const file = e.target.files[0];\n    if (!file) return;\n    const reader = new FileReader();\n    reader.onload = () => { document.getElementById('compose-yaml').value = reader.result; };\n    reader.readAsText(file);\n  });\n\n  // Parse\n  document.getElementById('compose-parse-btn')?.addEventListener('click', async () => {\n    const yamlStr = document.getElementById('compose-yaml').value.trim();\n    const stackName = document.getElementById('compose-stack-name').value.trim() || 'stack';\n    if (!yamlStr) { showNotification('Paste a docker-compose.yml', 'warning'); return; }\n\n    const btn = document.getElementById('compose-parse-btn');\n    const origText = btn.textContent;\n    btn.textContent = 'Parsing...';\n    btn.disabled = true;\n\n    try {\n      const data = await postJSON('/api/v1/apps/import-compose', { yaml: yamlStr, stackName });\n      parsedData = data;\n      parsedData.stackName = stackName;\n      renderPreview(data);\n      showStep('preview');\n    } catch (e) {\n      showNotification('Parse failed: ' + e.message, 'error');\n    } finally {\n      btn.textContent = origText;\n      btn.disabled = false;\n    }\n  });\n\n  function renderPreview(data) {\n    const container = document.getElementById('compose-preview-content');\n    let html = '';\n\n    if (data.networks && data.networks.length > 0) {\n      html += `<div style=\"margin-bottom: 12px; font-size: 0.82rem; color: var(--muted);\">Networks: ${data.networks.map(n => `<code>${escapeHtml(n)}</code>`).join(', ')}</div>`;\n    }\n    if (data.volumes && data.volumes.length > 0) {\n      html += `<div style=\"margin-bottom: 12px; font-size: 0.82rem; color: var(--muted);\">Volumes: ${data.volumes.map(v => `<code>${escapeHtml(v)}</code>`).join(', ')}</div>`;\n    }\n\n    html += `<div style=\"font-weight: 600; margin-bottom: 8px;\">${data.services.length} service(s)</div>`;\n    html += '<div class=\"scroll-container\" style=\"max-height: 350px;\">';\n\n    for (const svc of data.services) {\n      const borderColor = svc.skip ? 'var(--bad-fg)' : 'var(--border)';\n      html += `<div style=\"padding: 10px 14px; border: 1px solid ${borderColor}; border-radius: 8px; margin-bottom: 8px; background: var(--bg);\">`;\n      html += `<div style=\"font-weight: 600; font-size: 0.9rem;\">${escapeHtml(svc.name)}`;\n      if (svc.skip) html += ` <span style=\"color: var(--bad-fg); font-weight: 400; font-size: 0.78rem;\">\u2014 skipped: ${escapeHtml(svc.reason)}</span>`;\n      html += `</div>`;\n\n      if (!svc.skip) {\n        html += `<div style=\"font-size: 0.8rem; color: var(--muted); margin-top: 4px;\">Image: <code>${escapeHtml(svc.image)}</code></div>`;\n        if (svc.ports?.length) html += `<div style=\"font-size: 0.8rem; color: var(--muted);\">Ports: ${svc.ports.map(p => `${p.host}:${p.container}`).join(', ')}</div>`;\n        if (svc.volumes?.length) html += `<div style=\"font-size: 0.8rem; color: var(--muted);\">Volumes: ${svc.volumes.length}</div>`;\n        if (Object.keys(svc.environment || {}).length) html += `<div style=\"font-size: 0.8rem; color: var(--muted);\">Env vars: ${Object.keys(svc.environment).length}</div>`;\n        if (svc.envFileWarning) html += `<div style=\"font-size: 0.78rem; color: var(--bad-fg);\">\u26A0 ${escapeHtml(svc.envFileWarning)}</div>`;\n        if (svc.resources?.cpus || svc.resources?.memory) {\n          const parts = [];\n          if (svc.resources.cpus) parts.push(`CPU: ${svc.resources.cpus}`);\n          if (svc.resources.memory) parts.push(`Mem: ${svc.resources.memory}MB`);\n          html += `<div style=\"font-size: 0.8rem; color: var(--muted);\">Limits: ${parts.join(', ')}</div>`;\n        }\n      }\n\n      html += '</div>';\n    }\n    html += '</div>';\n    container.innerHTML = html;\n  }\n\n  // Back button\n  document.getElementById('compose-back-btn')?.addEventListener('click', () => showStep('paste'));\n\n  // Deploy\n  document.getElementById('compose-deploy-btn')?.addEventListener('click', async () => {\n    if (!parsedData) return;\n\n    const btn = document.getElementById('compose-deploy-btn');\n    btn.textContent = 'Deploying...';\n    btn.disabled = true;\n    showStep('progress');\n\n    const progressEl = document.getElementById('compose-progress-content');\n    progressEl.innerHTML = '<div class=\"panel-empty\"><span class=\"brand-spinner\"></span> Deploying services...</div>';\n\n    try {\n      const result = await postJSON('/api/v1/apps/deploy-compose', {\n        services: parsedData.services,\n        networks: parsedData.networks,\n        stackName: parsedData.stackName\n      });\n\n      let html = `<div style=\"font-weight: 600; margin-bottom: 12px;\">Stack \"${escapeHtml(result.stackName)}\" \u2014 Deployment Complete</div>`;\n      html += '<div class=\"scroll-container\" style=\"max-height: 350px;\">';\n\n      for (const r of result.results) {\n        const icon = r.status === 'deployed' || r.status === 'created' ? '\u2705' : r.status === 'exists' ? '\u26A1' : r.status === 'skipped' ? '\u23ED' : '\u274C';\n        html += `<div style=\"padding: 8px 12px; border-bottom: 1px solid var(--border); font-size: 0.85rem;\">`;\n        html += `${icon} <strong>${escapeHtml(r.name)}</strong> (${r.type}) \u2014 ${escapeHtml(r.status)}`;\n        if (r.error) html += ` <span style=\"color: var(--bad-fg);\">${escapeHtml(r.error)}</span>`;\n        if (r.subdomain) html += ` \u2192 <code>${escapeHtml(r.subdomain)}</code>`;\n        if (r.reason) html += ` <span style=\"color: var(--muted);\">(${escapeHtml(r.reason)})</span>`;\n        html += '</div>';\n      }\n      html += '</div>';\n      html += '<div class=\"weather-modal-buttons modal-footer-bar\" style=\"margin-top: 16px;\"><button id=\"compose-done-btn\">Done</button></div>';\n\n      progressEl.innerHTML = html;\n      document.getElementById('compose-done-btn')?.addEventListener('click', () => {\n        modal?.classList.remove('show');\n        if (typeof window.loadServices === 'function') window.loadServices().then(() => { if (typeof window.buildGrid === 'function') window.buildGrid(); });\n      });\n\n      showNotification(`Stack \"${result.stackName}\" deployed`, 'success');\n    } catch (e) {\n      progressEl.innerHTML = `<div class=\"panel-empty\" style=\"color: var(--bad-fg);\">Deployment failed: ${escapeHtml(e.message)}</div>\n        <div class=\"weather-modal-buttons modal-footer-bar\" style=\"margin-top: 16px;\"><button id=\"compose-retry-btn\">Back</button></div>`;\n      document.getElementById('compose-retry-btn')?.addEventListener('click', () => showStep('paste'));\n    } finally {\n      btn.textContent = 'Deploy All';\n      btn.disabled = false;\n    }\n  });\n})();\n;\n// ========== CONTAINER EXEC / SHELL (WebSocket + xterm.js) ==========\n(function() {\n  injectModal('exec-modal', `<div id=\"exec-modal\" class=\"weather-modal\">\n    <div class=\"weather-modal-content\" style=\"min-width: 700px; max-width: 900px; padding-bottom: 0;\">\n      <h3 id=\"exec-title\">Terminal</h3>\n      <div id=\"exec-terminal\" style=\"height: 420px; border-radius: 6px; overflow: hidden; background: #1e1e1e;\"></div>\n      <div class=\"weather-modal-buttons modal-footer-bar\" style=\"margin-top: 8px; padding-bottom: 12px;\">\n        <button id=\"exec-close\">Close</button>\n      </div>\n    </div>\n  </div>`);\n\n  const modal = document.getElementById('exec-modal');\n  const termEl = document.getElementById('exec-terminal');\n  const closeBtn = document.getElementById('exec-close');\n\n  let term = null;\n  let ws = null;\n  let fitAddon = null;\n\n  function cleanup() {\n    if (ws) { try { ws.close(); } catch (_) {} ws = null; }\n    if (term) { try { term.dispose(); } catch (_) {} term = null; }\n    fitAddon = null;\n    termEl.innerHTML = '';\n  }\n\n  function openExec(containerId, containerName) {\n    cleanup();\n\n    document.getElementById('exec-title').textContent = `Terminal \u2014 ${containerName || containerId}`;\n    modal?.classList.add('show');\n\n    // Ensure xterm is available\n    if (typeof Terminal === 'undefined') {\n      termEl.innerHTML = '<div style=\"color: #f44; padding: 20px; font-family: monospace;\">xterm.js not loaded</div>';\n      return;\n    }\n\n    term = new Terminal({\n      cursorBlink: true,\n      fontSize: 14,\n      fontFamily: \"'Cascadia Code', 'Fira Code', 'Consolas', monospace\",\n      theme: {\n        background: '#1e1e1e',\n        foreground: '#d4d4d4',\n        cursor: '#aeafad',\n        selectionBackground: '#264f78',\n      },\n      scrollback: 5000,\n    });\n\n    // Fit addon\n    if (typeof FitAddon !== 'undefined') {\n      fitAddon = new FitAddon.FitAddon();\n      term.loadAddon(fitAddon);\n    }\n\n    term.open(termEl);\n    if (fitAddon) {\n      // Small delay for DOM to settle\n      setTimeout(() => fitAddon.fit(), 50);\n    }\n\n    // Connect WebSocket\n    const protocol = location.protocol === 'https:' ? 'wss:' : 'ws:';\n    ws = new WebSocket(`${protocol}//${location.host}/ws/exec/${encodeURIComponent(containerId)}`);\n    ws.binaryType = 'arraybuffer';\n\n    ws.onopen = () => {\n      term.writeln('\\x1b[32mConnecting...\\x1b[0m');\n      // Send initial resize\n      if (fitAddon) {\n        const dims = fitAddon.proposeDimensions();\n        if (dims) {\n          ws.send(JSON.stringify({ type: 'resize', cols: dims.cols, rows: dims.rows }));\n        }\n      }\n    };\n\n    ws.onmessage = (e) => {\n      if (typeof e.data === 'string') {\n        try {\n          const msg = JSON.parse(e.data);\n          if (msg.type === 'connected') {\n            term.writeln(`\\x1b[32mConnected (${msg.shell})\\x1b[0m\\r\\n`);\n            return;\n          }\n          if (msg.type === 'error') {\n            term.writeln(`\\x1b[31mError: ${msg.message}\\x1b[0m`);\n            return;\n          }\n          if (msg.type === 'exit') {\n            term.writeln('\\r\\n\\x1b[33mSession ended.\\x1b[0m');\n            return;\n          }\n        } catch (_) {}\n        // Plain text\n        term.write(e.data);\n      } else {\n        // Binary data\n        term.write(new Uint8Array(e.data));\n      }\n    };\n\n    ws.onclose = () => {\n      if (term) term.writeln('\\r\\n\\x1b[33mDisconnected.\\x1b[0m');\n    };\n\n    ws.onerror = () => {\n      if (term) term.writeln('\\r\\n\\x1b[31mConnection error.\\x1b[0m');\n    };\n\n    // Terminal input \u2192 WebSocket\n    term.onData((data) => {\n      if (ws && ws.readyState === WebSocket.OPEN) {\n        ws.send(data);\n      }\n    });\n\n    // Handle resize\n    term.onResize(({ cols, rows }) => {\n      if (ws && ws.readyState === WebSocket.OPEN) {\n        ws.send(JSON.stringify({ type: 'resize', cols, rows }));\n      }\n    });\n\n    // Re-fit on window resize\n    const resizeHandler = () => { if (fitAddon) fitAddon.fit(); };\n    window.addEventListener('resize', resizeHandler);\n\n    // Store handler for cleanup\n    modal._resizeHandler = resizeHandler;\n  }\n\n  closeBtn?.addEventListener('click', () => {\n    cleanup();\n    if (modal._resizeHandler) {\n      window.removeEventListener('resize', modal._resizeHandler);\n    }\n    modal?.classList.remove('show');\n  });\n\n  // Also close on backdrop click\n  modal?.addEventListener('click', (e) => {\n    if (e.target === modal) {\n      cleanup();\n      if (modal._resizeHandler) {\n        window.removeEventListener('resize', modal._resizeHandler);\n      }\n      modal?.classList.remove('show');\n    }\n  });\n\n  // Export\n  window.openExecModal = openExec;\n})();\n;\n// ========== AUDIT LOG VIEWER ==========\n// DC-050: surface authenticated user identity (userEmail / userRole from\n// auditLogger.details), add outcome filter, pass confirm=CLEAR body for\n// destructive DELETE.\n(function() {\n  // Inject modal HTML\n  injectModal('audit-modal', `<div id=\"audit-modal\" class=\"weather-modal\">\n    <div class=\"weather-modal-content\" style=\"min-width: 950px; max-width: 1150px;\">\n      <h3>\uD83D\uDCDC Audit Log</h3>\n      <p class=\"modal-subtitle\">\n        Track all actions performed through the API.\n      </p>\n\n      <div style=\"display: flex; gap: 12px; margin-bottom: 12px; align-items: center; flex-wrap: wrap;\">\n        <label class=\"text-muted-sm\">Category:</label>\n        <select id=\"audit-filter\" style=\"padding: 6px 10px; border-radius: 6px; border: 1px solid var(--border); background: var(--bg); color: var(--fg); font-size: 0.85rem;\">\n          <option value=\"\">All</option>\n          <option value=\"service\">Services</option>\n          <option value=\"container\">Containers</option>\n          <option value=\"caddy\">Caddy</option>\n          <option value=\"dns\">DNS</option>\n          <option value=\"backup\">Backups</option>\n          <option value=\"config\">Config</option>\n          <option value=\"auth\">Auth</option>\n        </select>\n        <label class=\"text-muted-sm\">Result:</label>\n        <select id=\"audit-outcome-filter\" style=\"padding: 6px 10px; border-radius: 6px; border: 1px solid var(--border); background: var(--bg); color: var(--fg); font-size: 0.85rem;\">\n          <option value=\"\">Any</option>\n          <option value=\"success\">\u2713 Success</option>\n          <option value=\"failure\">\u2717 Failure</option>\n        </select>\n        <label class=\"text-muted-sm\" style=\"margin-left: 8px;\">Since:</label>\n        <input id=\"audit-since\" type=\"datetime-local\" style=\"padding: 5px 8px; border-radius: 6px; border: 1px solid var(--border); background: var(--bg); color: var(--fg); font-size: 0.82rem;\">\n        <label class=\"text-muted-sm\">Until:</label>\n        <input id=\"audit-until\" type=\"datetime-local\" style=\"padding: 5px 8px; border-radius: 6px; border: 1px solid var(--border); background: var(--bg); color: var(--fg); font-size: 0.82rem;\">\n        <button id=\"audit-refresh-btn\" class=\"btn-sm\">\uD83D\uDD04 Refresh</button>\n        <span style=\"flex: 1;\"></span>\n        <button id=\"audit-clear-btn\" style=\"padding: 6px 12px; font-size: 0.8rem; color: var(--bad-fg); border-color: var(--bad-fg);\">\uD83D\uDDD1\uFE0F Clear Log</button>\n      </div>\n\n      <div id=\"audit-log-container\" class=\"scroll-container\">\n        <div class=\"panel-empty\"><span class=\"brand-spinner\"></span> Loading audit log...</div>\n      </div>\n\n      <div style=\"margin-top: 12px; text-align: center;\">\n        <button id=\"audit-load-more\" style=\"display: none; padding: 6px 16px; font-size: 0.8rem;\">Load More</button>\n      </div>\n\n      <div class=\"weather-modal-buttons modal-footer-bar\">\n        <button id=\"audit-cancel\">Close</button>\n      </div>\n    </div>\n  </div>`);\n\n  const modal = document.getElementById('audit-modal');\n  const openBtn = document.getElementById('audit-log-btn');\n  const cancelBtn = document.getElementById('audit-cancel');\n  const refreshBtn = document.getElementById('audit-refresh-btn');\n  const clearBtn = document.getElementById('audit-clear-btn');\n  const filterSelect = document.getElementById('audit-filter');\n  const outcomeSelect = document.getElementById('audit-outcome-filter');\n  const sinceInput = document.getElementById('audit-since');\n  const untilInput = document.getElementById('audit-until');\n  const container = document.getElementById('audit-log-container');\n  const loadMoreBtn = document.getElementById('audit-load-more');\n  let currentOffset = 0;\n  let inflight = null; // AbortController for the in-flight request\n  let filterNonce = 0; // increments on every fresh (non-append) load; lets\n                       // an in-flight append detect the filter has changed\n                       // and skip its DOM splice.\n  const PAGE_SIZE = 50;\n\n  // datetime-local fields carry no timezone offset \u2014 convert to ISO 8601\n  // with the local offset so the server can compare correctly.\n  function toIso(localDtValue) {\n    if (!localDtValue) return null;\n    // Browsers expose datetime-local as naive local time. new Date() on\n    // that string parses it as LOCAL, so toISOString() yields the UTC\n    // equivalent the server expects.\n    const d = new Date(localDtValue);\n    if (isNaN(d.getTime())) return null;\n    return d.toISOString();\n  }\n\n  async function loadAudit(append) {\n    try {\n      if (!append) {\n        // Cancel any pending request and bump the filter nonce so any\n        // appending fetch (still in flight) knows to discard its response.\n        if (inflight) inflight.abort();\n        inflight = new AbortController();\n        currentOffset = 0;\n        filterNonce++;\n        container.innerHTML = '<div class=\"panel-empty\"><span class=\"brand-spinner\"></span> Loading...</div>';\n      } else {\n        if (inflight) inflight.abort();\n        inflight = new AbortController();\n      }\n      const myNonce = filterNonce;\n      const params = new URLSearchParams();\n      params.set('limit', String(PAGE_SIZE));\n      params.set('offset', String(currentOffset));\n      const action = filterSelect.value;\n      const outcome = outcomeSelect.value;\n      const since = toIso(sinceInput.value);\n      const until = toIso(untilInput.value);\n      if (action) params.set('action', action);\n      if (outcome) params.set('outcome', outcome);\n      if (since) params.set('since', since);\n      if (until) params.set('until', until);\n\n      const res = await fetch('/api/v1/audit-logs?' + params.toString(), {\n        signal: inflight.signal,\n      });\n      // Surface 401/403/500 explicitly \u2014 the dashboard used to render any\n      // non-success response as \"no audit log entries yet,\" which is\n      // misleading for an expired session.\n      if (!res.ok) {\n        container.innerHTML = `<div class=\"panel-empty\" style=\"color: var(--bad-fg);\">Failed: HTTP ${res.status}</div>`;\n        loadMoreBtn.style.display = 'none';\n        return;\n      }\n      const data = await res.json();\n      if (!data.success) {\n        container.innerHTML = `<div class=\"panel-empty\" style=\"color: var(--bad-fg);\">Failed: ${escapeHtml(data.error || 'unknown')}</div>`;\n        loadMoreBtn.style.display = 'none';\n        return;\n      }\n      // If a non-append load happened after this fetch was issued, the\n      // operator changed filters; discard the now-stale response.\n      if (!append && myNonce !== filterNonce) return;\n      const entries = Array.isArray(data.entries) ? data.entries : [];\n\n      if (entries.length === 0 && !append) {\n        const reason = data.filters && (data.filters.action || data.filters.outcome || data.filters.since || data.filters.until)\n          ? 'No entries match your filters.'\n          : 'No audit log entries yet. Actions will be logged automatically.';\n        container.innerHTML = `<div class=\"panel-empty\"><span class=\"empty-icon\">\uD83D\uDCDC</span>${escapeHtml(reason)}</div>`;\n        loadMoreBtn.style.display = 'none';\n        return;\n      }\n\n      let html = '';\n      if (!append) {\n        html = '<table style=\"width: 100%; border-collapse: collapse; font-size: 0.82rem;\">';\n        html += '<tr style=\"border-bottom: 1px solid var(--border); color: var(--muted);\">';\n        html += '<th style=\"padding: 6px; text-align: left;\">When</th>';\n        html += '<th style=\"padding: 6px; text-align: left;\">Actor</th>';\n        html += '<th style=\"padding: 6px; text-align: left;\">IP</th>';\n        html += '<th style=\"padding: 6px; text-align: left;\">Action</th>';\n        html += '<th style=\"padding: 6px; text-align: left;\">Resource</th>';\n        html += '<th style=\"padding: 6px; text-align: left;\">Result</th>';\n        html += '</tr>';\n      }\n\n      for (const e of entries) {\n        const ok = e.outcome === 'success';\n        const actor = actorLabel(e);\n        html += `<tr style=\"border-bottom: 1px solid var(--border); cursor: pointer;\" class=\"audit-row\">`;\n        html += `<td style=\"padding: 6px; color: var(--muted);\" title=\"${escapeHtml(e.timestamp || '')}\">${timeAgo(e.timestamp)}</td>`;\n        html += `<td style=\"padding: 6px; font-size: 0.78rem;\">${actor}</td>`;\n        html += `<td style=\"padding: 6px; font-family: monospace; font-size: 0.78rem;\">${escapeHtml(e.ip || '-')}</td>`;\n        html += `<td style=\"padding: 6px; font-weight: 500;\">${escapeHtml(e.action || '-')}</td>`;\n        html += `<td style=\"padding: 6px;\">${escapeHtml(e.resource || '-')}</td>`;\n        html += `<td style=\"padding: 6px;\"><span style=\"color: ${ok ? 'var(--ok-fg)' : 'var(--bad-fg)'};\">${ok ? '\u2713' : '\u2717'} ${escapeHtml(e.outcome || '')}</span></td>`;\n        html += '</tr>';\n        if (e.details && Object.keys(e.details).length > 0) {\n          html += `<tr class=\"audit-detail\" style=\"display: none;\"><td colspan=\"6\" style=\"padding: 6px 6px 10px; font-size: 0.78rem; color: var(--muted);\"><pre style=\"margin: 0; white-space: pre-wrap; font-family: monospace;\">${escapeHtml(JSON.stringify(e.details, null, 2))}</pre></td></tr>`;\n        }\n      }\n\n      if (!append) {\n        html += '</table>';\n        container.innerHTML = html;\n      } else {\n        const table = container.querySelector('table');\n        if (table) table.insertAdjacentHTML('beforeend', html);\n      }\n\n      currentOffset += entries.length;\n      // hasMore is reported by the server (post-filter total), so the\n      // Load More button stays accurate when filters change mid-scroll.\n      loadMoreBtn.style.display = data.hasMore ? '' : 'none';\n\n      // Toggle detail rows on click\n      container.querySelectorAll('.audit-row').forEach(row => {\n        if (row.dataset.wired) return;\n        row.dataset.wired = 'true';\n        row.addEventListener('click', () => {\n          const detail = row.nextElementSibling;\n          if (detail && detail.classList.contains('audit-detail')) {\n            detail.style.display = detail.style.display === 'none' ? '' : 'none';\n          }\n        });\n      });\n    } catch (e) {\n      // AbortError is expected when we deliberately cancel an in-flight\n      // request (e.g. the operator changed filters mid-fetch) \u2014 don't\n      // flash a \"Failed: The user aborted a request\" message over the\n      // loading spinner. The new fetch has already kicked off.\n      if (e && e.name === 'AbortError') return;\n      container.innerHTML = `<div class=\"panel-empty\" style=\"color: var(--bad-fg);\">Failed: ${escapeHtml(e.message)}</div>`;\n    }\n  }\n\n  // Render the human-readable actor: prefer userEmail, fall back to\n  // userId, fall back to bare IP. If no user attribution, mark as\n  // \"system\" so the operator knows the entry came from an unauthenticated\n  // or service path (e.g. cron-driven backups).\n  function actorLabel(entry) {\n    const d = entry.details || {};\n    const email = d.userEmail;\n    const id = d.userId;\n    const role = d.userRole;\n    const provider = d.viaProvider;\n    if (email) {\n      const tag = role ? ` <span style=\"color: var(--muted); font-size: 0.72rem;\">[${escapeHtml(role)}${provider ? '/' + escapeHtml(provider) : ''}]</span>` : '';\n      return `${escapeHtml(email)}${tag}`;\n    }\n    if (id) return `<span style=\"font-family: monospace; color: var(--muted);\">${escapeHtml(id)}</span>`;\n    if (!entry.ip) return '<span style=\"color: var(--muted);\">system</span>';\n    return '<span style=\"color: var(--muted);\">anon</span>';\n  }\n\n  openBtn?.addEventListener('click', () => {\n    modal?.classList.add('show');\n    loadAudit(false);\n  });\n  wireModal(modal, cancelBtn);\n  refreshBtn?.addEventListener('click', () => loadAudit(false));\n  filterSelect?.addEventListener('change', () => loadAudit(false));\n  outcomeSelect?.addEventListener('change', () => loadAudit(false));\n  // Re-fetch on date change only when both fields have a value or both are\n  // empty \u2014 typing one character shouldn't trigger a fetch for every keystroke.\n  let dateDebounce;\n  [sinceInput, untilInput].forEach((el) => {\n    el?.addEventListener('change', () => {\n      clearTimeout(dateDebounce);\n      dateDebounce = setTimeout(() => loadAudit(false), 250);\n    });\n  });\n  loadMoreBtn?.addEventListener('click', () => loadAudit(true));\n\n  clearBtn?.addEventListener('click', async () => {\n    if (!confirm('Clear the entire audit log? This cannot be undone.')) return;\n    try {\n      const res = await secureFetch('/api/v1/audit-logs', {\n        method: 'DELETE',\n        headers: { 'content-type': 'application/json' },\n        body: JSON.stringify({ confirm: 'CLEAR' }),\n      });\n      const data = await res.json();\n      if (data.success) loadAudit(false);\n      else showNotification('Error: ' + (data.error || 'Clear failed'), 'error');\n    } catch (e) {\n      showNotification('Error: ' + e.message, 'error');\n    }\n  });\n})();;\n// ========== SECURITY CENTER ==========\n// Multi-source security event viewer + host registry UI.\n//\n// Shows live events from any source (API audit, Caddy access log, fail2ban,\n// shared_bans) on any registered host (this DashCaddy, future remote agents).\n//\n// Live-tail uses SSE (/api/v1/security/events/stream).\n(function() {\n  injectModal('security-modal', `<div id=\"security-modal\" class=\"weather-modal\">\n    <div class=\"weather-modal-content\" style=\"min-width: 980px; max-width: 1280px;\">\n      <h3>\uD83D\uDEE1\uFE0F Security Center</h3>\n      <p class=\"modal-subtitle\">\n        Live events from API, Caddy, fail2ban & shared_bans. Live-tail via SSE.\n      </p>\n\n      <div class=\"sec-tabs\" style=\"display:flex;gap:8px;margin-bottom:14px;border-bottom:1px solid var(--border);\">\n        <button class=\"sec-tab active\" data-tab=\"overview\">Overview</button>\n        <button class=\"sec-tab\" data-tab=\"events\">Events</button>\n        <button class=\"sec-tab\" data-tab=\"hosts\">Hosts</button>\n      </div>\n\n      <!-- OVERVIEW TAB -->\n      <div class=\"sec-panel\" data-panel=\"overview\">\n        <div class=\"sec-stats\" id=\"sec-stats\" style=\"display:grid;grid-template-columns:repeat(auto-fit,minmax(180px,1fr));gap:12px;margin-bottom:18px;\">\n          <div class=\"sec-stat\" data-key=\"total\">\u2014 events</div>\n          <div class=\"sec-stat\" data-key=\"warn\">\u2014 warnings</div>\n          <div class=\"sec-stat\" data-key=\"error\">\u2014 errors</div>\n          <div class=\"sec-stat\" data-key=\"denied\">\u2014 denied</div>\n          <div class=\"sec-stat\" data-key=\"hosts\">\u2014 hosts</div>\n        </div>\n        <div style=\"display:grid;grid-template-columns:1fr 1fr;gap:14px;\">\n          <div>\n            <h4 style=\"margin:8px 0 6px;\">Top Actors (24h)</h4>\n            <div id=\"sec-top-actors\" class=\"scroll-container\" style=\"max-height:240px;\">\u2014</div>\n          </div>\n          <div>\n            <h4 style=\"margin:8px 0 6px;\">Top Targets (24h)</h4>\n            <div id=\"sec-top-targets\" class=\"scroll-container\" style=\"max-height:240px;\">\u2014</div>\n          </div>\n        </div>\n      </div>\n\n      <!-- EVENTS TAB -->\n      <div class=\"sec-panel\" data-panel=\"events\" style=\"display:none;\">\n        <div style=\"display:flex;gap:8px;margin-bottom:12px;align-items:center;flex-wrap:wrap;\">\n          <select id=\"sec-filter-source\" class=\"sec-filter\">\n            <option value=\"\">All sources</option>\n            <option value=\"api\">API</option>\n            <option value=\"caddy\">Caddy</option>\n            <option value=\"fail2ban\">fail2ban</option>\n            <option value=\"shared-bans\">shared_bans</option>\n            <option value=\"agent\">Agent</option>\n          </select>\n          <select id=\"sec-filter-severity\" class=\"sec-filter\">\n            <option value=\"\">All severities</option>\n            <option value=\"critical\">critical</option>\n            <option value=\"error\">error</option>\n            <option value=\"warn\">warn</option>\n            <option value=\"notice\">notice</option>\n            <option value=\"info\">info</option>\n          </select>\n          <select id=\"sec-filter-host\" class=\"sec-filter\">\n            <option value=\"\">All hosts</option>\n          </select>\n          <input id=\"sec-filter-actor\" class=\"sec-filter\" placeholder=\"actor (IP or user)\" style=\"padding:6px 10px;\">\n          <button id=\"sec-refresh-btn\" class=\"btn-sm\">\uD83D\uDD04 Refresh</button>\n          <label style=\"margin-left:auto;display:flex;align-items:center;gap:6px;\">\n            <input type=\"checkbox\" id=\"sec-live-tail\" checked>\n            <span>Live tail</span>\n          </label>\n        </div>\n        <div id=\"sec-events-container\" class=\"scroll-container\" style=\"max-height:480px;\">Loading\u2026</div>\n      </div>\n\n      <!-- HOSTS TAB -->\n      <div class=\"sec-panel\" data-panel=\"hosts\" style=\"display:none;\">\n        <div style=\"display:flex;gap:8px;margin-bottom:12px;\">\n          <button id=\"sec-host-register-btn\" class=\"btn-sm\">\u2795 Register Host</button>\n          <button id=\"sec-hosts-refresh\" class=\"btn-sm\">\uD83D\uDD04 Refresh</button>\n        </div>\n        <div id=\"sec-hosts-container\" class=\"scroll-container\" style=\"max-height:480px;\">Loading\u2026</div>\n      </div>\n\n      <div class=\"weather-modal-buttons modal-footer-bar\">\n        <button id=\"sec-cancel\">Close</button>\n      </div>\n    </div>\n  </div>`);\n\n  // ============= STATE =============\n  const modal = document.getElementById('security-modal');\n  const openBtn = document.getElementById('security-center-btn');\n  const cancelBtn = document.getElementById('sec-cancel');\n  const tabs = modal.querySelectorAll('.sec-tab');\n  const panels = modal.querySelectorAll('.sec-panel');\n\n  let allEvents = []; // newest first\n  let allHosts = [];\n  let sseSource = null;\n\n  // ============= TAB SWITCHING =============\n  tabs.forEach(tab => {\n    tab.addEventListener('click', () => {\n      tabs.forEach(t => t.classList.toggle('active', t === tab));\n      panels.forEach(p => p.style.display = p.dataset.panel === tab.dataset.tab ? '' : 'none');\n      if (tab.dataset.tab === 'overview') refreshOverview();\n      if (tab.dataset.tab === 'events') refreshEvents();\n      if (tab.dataset.tab === 'hosts') refreshHosts();\n    });\n  });\n\n  // ============= OPEN/CLOSE =============\n  if (openBtn) {\n    openBtn.addEventListener('click', () => {\n      modal.classList.add('show');\n      refreshOverview();\n      startLiveTail();\n    });\n  }\n  cancelBtn.addEventListener('click', closeModal);\n  modal.addEventListener('click', e => { if (e.target === modal) closeModal(); });\n  function closeModal() {\n    modal.classList.remove('show');\n    stopLiveTail();\n  }\n\n  // ============= LIVE TAIL (SSE) =============\n  function startLiveTail() {\n    stopLiveTail();\n    if (!document.getElementById('sec-live-tail').checked) return;\n    if (typeof EventSource === 'undefined') return; // browser doesn't support\n    try {\n      sseSource = new EventSource('/api/v1/security/events/stream');\n      sseSource.addEventListener('init', (e) => {\n        try {\n          const data = JSON.parse(e.data);\n          allEvents = data.events || [];\n          renderEvents();\n        } catch {}\n      });\n      sseSource.addEventListener('security', (e) => {\n        try {\n          const ev = JSON.parse(e.data);\n          allEvents.unshift(ev);\n          if (allEvents.length > 500) allEvents.length = 500;\n          // Auto-refresh whichever panel is showing\n          const active = modal.querySelector('.sec-tab.active')?.dataset?.tab;\n          if (active === 'events') renderEvents();\n          else if (active === 'overview') refreshOverview();\n        } catch {}\n      });\n      sseSource.onerror = () => { /* browser auto-reconnects */ };\n    } catch (e) {\n      console.warn('[security] SSE failed:', e.message);\n    }\n  }\n  function stopLiveTail() {\n    if (sseSource) { try { sseSource.close(); } catch {} sseSource = null; }\n  }\n  document.getElementById('sec-live-tail').addEventListener('change', () => {\n    if (modal.classList.contains('show')) startLiveTail();\n  });\n\n  // ============= OVERVIEW =============\n  async function refreshOverview() {\n    try {\n      const since = new Date(Date.now() - 24*60*60*1000).toISOString();\n      const [statsRes, hostsRes, eventsRes] = await Promise.all([\n        fetch(`/api/v1/security/events/stats?since=${encodeURIComponent(since)}`),\n        fetch('/api/v1/security/hosts'),\n        fetch(`/api/v1/security/events?limit=1&since=${encodeURIComponent(since)}`),\n      ]);\n      const stats = (await statsRes.json()).data || {};\n      const hosts = (await hostsRes.json()).data?.hosts || [];\n      const eventsCount = (await eventsRes.json()).data?.total || 0;\n\n      document.querySelector('#sec-stats [data-key=\"total\"]').textContent = `${eventsCount} events (24h)`;\n      document.querySelector('#sec-stats [data-key=\"warn\"]').textContent = `${stats.by_severity?.warn || 0} warnings`;\n      document.querySelector('#sec-stats [data-key=\"error\"]').textContent = `${stats.by_severity?.error || 0} errors`;\n      document.querySelector('#sec-stats [data-key=\"denied\"]').textContent = `${stats.by_outcome?.denied || 0} denied`;\n      document.querySelector('#sec-stats [data-key=\"hosts\"]').textContent = `${hosts.length} hosts`;\n\n      renderTopList('sec-top-actors', stats.top_actors || []);\n      renderTopList('sec-top-targets', stats.top_targets || []);\n    } catch (e) {\n      console.warn('[security] refreshOverview failed:', e.message);\n    }\n  }\n  function renderTopList(id, items) {\n    const el = document.getElementById(id);\n    if (!items.length) { el.innerHTML = '<div class=\"panel-empty\">No data</div>'; return; }\n    el.innerHTML = '<table style=\"width:100%;font-size:0.85rem;\">' +\n      items.map(it => `<tr><td style=\"padding:3px 0;word-break:break-all;\">${escapeHtml(String(it.key))}</td><td style=\"text-align:right;color:var(--muted);\">${it.count}</td></tr>`).join('') +\n      '</table>';\n  }\n\n  // ============= EVENTS =============\n  const filterSource = document.getElementById('sec-filter-source');\n  const filterSeverity = document.getElementById('sec-filter-severity');\n  const filterHost = document.getElementById('sec-filter-host');\n  const filterActor = document.getElementById('sec-filter-actor');\n  const refreshBtn = document.getElementById('sec-refresh-btn');\n\n  [filterSource, filterSeverity, filterHost].forEach(el => el.addEventListener('change', refreshEvents));\n  filterActor.addEventListener('input', debounce(refreshEvents, 250));\n  refreshBtn.addEventListener('click', refreshEvents);\n\n  async function refreshEvents() {\n    try {\n      const params = new URLSearchParams();\n      params.set('limit', '200');\n      if (filterSource.value)  params.set('source_type', filterSource.value);\n      if (filterSeverity.value) params.set('severity', filterSeverity.value);\n      if (filterHost.value)    params.set('source_host', filterHost.value);\n      if (filterActor.value)   params.set('actor_prefix', filterActor.value);\n\n      const res = await fetch(`/api/v1/security/events?${params}`);\n      const data = (await res.json()).data;\n      allEvents = data.events || [];\n      renderEvents();\n\n      // Refresh host dropdown if we don't have it yet\n      if (!filterHost.options.length || filterHost.options.length === 1) {\n        await refreshHostFilter();\n      }\n    } catch (e) {\n      document.getElementById('sec-events-container').innerHTML = '<div class=\"panel-empty\">Load failed: '+escapeHtml(e.message)+'</div>';\n    }\n  }\n\n  function renderEvents() {\n    const el = document.getElementById('sec-events-container');\n    if (!allEvents.length) { el.innerHTML = '<div class=\"panel-empty\">No events</div>'; return; }\n    el.innerHTML = allEvents.slice(0, 200).map(renderEventRow).join('');\n  }\n\n  function renderEventRow(ev) {\n    const sev = ev.severity || 'info';\n    const sevColor = {\n      critical: '#c0392b', error: '#e74c3c', warn: '#f39c12',\n      notice: '#3498db', info: '#7f8c8d',\n    }[sev] || '#7f8c8d';\n    const time = ev.ts ? new Date(ev.ts).toLocaleTimeString() : '';\n    const source = ev.source_type || '';\n    const actor = ev.actor || '\u2014';\n    const target = ev.target || '';\n    const action = ev.action || '';\n    const outcome = ev.outcome || '';\n    return `<div class=\"sec-event-row\" style=\"display:grid;grid-template-columns:84px 80px 1fr 1fr 100px 90px;gap:8px;padding:5px 8px;border-bottom:1px solid var(--border);font-size:0.82rem;align-items:center;\">\n      <span style=\"color:${sevColor};font-weight:600;\">${escapeHtml(sev)}</span>\n      <span style=\"color:var(--muted);font-size:0.75rem;\">${escapeHtml(source)}</span>\n      <span title=\"${escapeHtml(actor)}\" style=\"overflow:hidden;text-overflow:ellipsis;white-space:nowrap;\">${escapeHtml(actor)}</span>\n      <span title=\"${escapeHtml(target)}\" style=\"overflow:hidden;text-overflow:ellipsis;white-space:nowrap;\">${escapeHtml(action)} ${escapeHtml(target)}</span>\n      <span style=\"color:var(--muted);font-size:0.75rem;\">${escapeHtml(outcome)}</span>\n      <span style=\"color:var(--muted);font-size:0.75rem;text-align:right;\">${escapeHtml(time)}</span>\n    </div>`;\n  }\n\n  async function refreshHostFilter() {\n    try {\n      const res = await fetch('/api/v1/security/hosts');\n      const hosts = (await res.json()).data?.hosts || [];\n      const current = filterHost.value;\n      filterHost.innerHTML = '<option value=\"\">All hosts</option>' +\n        hosts.map(h => `<option value=\"${escapeHtml(h.id)}\">${escapeHtml(h.label || h.id)}</option>`).join('');\n      if (current) filterHost.value = current;\n    } catch {}\n  }\n\n  // ============= HOSTS =============\n  document.getElementById('sec-host-register-btn').addEventListener('click', registerHostPrompt);\n  document.getElementById('sec-hosts-refresh').addEventListener('click', refreshHosts);\n\n  async function refreshHosts() {\n    try {\n      const res = await fetch('/api/v1/security/hosts');\n      const hosts = (await res.json()).data?.hosts || [];\n      allHosts = hosts;\n      const el = document.getElementById('sec-hosts-container');\n      if (!hosts.length) { el.innerHTML = '<div class=\"panel-empty\">No hosts registered. Click \u2795 Register Host to add one.</div>'; return; }\n      el.innerHTML = hosts.map(h => {\n        const status = !h.enabled ? '\uD83D\uDD34 disabled'\n                     : !h.last_seen_at ? '\u26AA registered'\n                     : (Date.now() - Date.parse(h.last_seen_at) > 30*60*1000) ? '\uD83D\uDFE1 stale'\n                     : '\uD83D\uDFE2 online';\n        return `<div style=\"padding:10px 12px;border-bottom:1px solid var(--border);display:flex;justify-content:space-between;align-items:center;\">\n          <div>\n            <strong>${escapeHtml(h.label || h.id)}</strong>\n            <span style=\"color:var(--muted);margin-left:8px;font-size:0.8rem;\">${escapeHtml(h.type)}</span>\n            <div style=\"color:var(--muted);font-size:0.78rem;margin-top:2px;\">\n              id: ${escapeHtml(h.id)} \u00B7\n              registered ${new Date(h.registered_at).toLocaleDateString()} \u00B7\n              last seen ${h.last_seen_at ? new Date(h.last_seen_at).toLocaleString() : 'never'}\n            </div>\n          </div>\n          <div>\n            <span style=\"font-size:0.85rem;margin-right:12px;\">${status}</span>\n            ${h.id === 'self' ? '' : `<button class=\"btn-sm sec-host-del\" data-id=\"${escapeHtml(h.id)}\" style=\"color:var(--bad-fg);\">Remove</button>`}\n          </div>\n        </div>`;\n      }).join('');\n\n      el.querySelectorAll('.sec-host-del').forEach(btn => {\n        btn.addEventListener('click', async () => {\n          if (!confirm(`Remove host ${btn.dataset.id}? Events already received will remain in the store.`)) return;\n          await fetch(`/api/v1/security/hosts/${encodeURIComponent(btn.dataset.id)}`, { method: 'DELETE' });\n          refreshHosts();\n        });\n      });\n    } catch (e) {\n      document.getElementById('sec-hosts-container').innerHTML = '<div class=\"panel-empty\">Load failed: '+escapeHtml(e.message)+'</div>';\n    }\n  }\n\n  async function registerHostPrompt() {\n    const id = prompt('Host id (lowercase, no spaces):');\n    if (!id) return;\n    const label = prompt('Display label:', id) || id;\n    const type  = prompt('Type (\"dashcaddy\", \"service\", or \"agent\"):', 'agent') || 'agent';\n    try {\n      const res = await fetch('/api/v1/security/hosts', {\n        method: 'POST',\n        headers: { 'Content-Type': 'application/json' },\n        body: JSON.stringify({ id, label, type }),\n      });\n      const data = await res.json();\n      if (!res.ok) { alert('Failed: ' + (data?.error?.message || res.statusText)); return; }\n      // Show the api_key ONCE in a dialog\n      alert(`\u2705 Host registered!\\n\\nid: ${data.data.host.id}\\nlabel: ${data.data.host.label}\\ntype: ${data.data.host.type}\\n\\n\uD83D\uDD11 API KEY (save this NOW \u2014 won't be shown again):\\n\\n${data.data.api_key}\\n\\nSend this key as: Authorization: Bearer <api_key>\\nTo endpoint: POST /api/v1/security/events/ingest or /events/batch`);\n      refreshHosts();\n    } catch (e) {\n      alert('Failed: ' + e.message);\n    }\n  }\n\n  // ============= HELPERS =============\n  function escapeHtml(s) {\n    return String(s).replace(/[&<>\"']/g, c => ({'&':'&amp;','<':'&lt;','>':'&gt;','\"':'&quot;',\"'\":'&#39;'}[c]));\n  }\n  function debounce(fn, ms) {\n    let t; return function() { clearTimeout(t); t = setTimeout(() => fn.apply(this, arguments), ms); };\n  }\n})();;\n// ========== SHIPDECK DEPLOYS (DC-130) ==========\n// Source deploys panel: drives the shipdeck CLI via the DashCaddy\n// /api/v1/deploys bridge proxy. Modal lists deployable repos + deployed\n// services, shows the journal, and runs deploy/rollback with live output.\n//\n// Follows the security-center.js modal pattern (injectModal + button in the\n// top bar) and the weather-modal visual language.\n\n// DC-133: pure repo-option builder. Remote Gitea fields are UNTRUSTED (a\n// hostile instance controls full_name/description/url), so every\n// interpolated value must be HTML-escaped before innerHTML. Exposed on\n// window so status/tests can pin the escaping with hostile payloads.\nwindow.__dc133_buildRepoOptions = function (repos, escFn) {\n  var e = escFn || function (s) {\n    return String(s).replace(/[&<>\"']/g, function (c) {\n      return { '&': '&amp;', '<': '&lt;', '>': '&gt;', '\"': '&quot;', \"'\": '&#39;' }[c];\n    });\n  };\n  return '<option value=\"\">\u2014 choose a repo \u2014</option>' +\n    (repos || []).map(function (r) {\n      return '<option value=\"' + e(r.url) + '\" data-id=\"' + e(r.id) + '\">' +\n        e(r.full_name) + (r.description ? ' \u2014 ' + e(r.description) : '') + '</option>';\n    }).join('');\n};\n\n// Three-state token semantics, exposed for VM tests:\n// anonymous=true -> explicit empty; typed value -> token; neither -> omitted.\nwindow.__dc133_requestToken = function (anonymous, typed) {\n  if (anonymous) return '';\n  var t = String(typed || '').trim();\n  return t || undefined;\n};\n\n(function () {\n  injectModal('deploys-modal', `<div id=\"deploys-modal\" class=\"weather-modal\">\n    <div class=\"weather-modal-content\" style=\"min-width: 860px; max-width: 1200px;\">\n      <h3>\uD83D\uDE9A Deploys</h3>\n      <p class=\"modal-subtitle\">\n        Source deploys via shipdeck: build \u2192 package \u2192 systemd release \u2192 Caddy gate \u2192 DNS \u2192 verify.\n      </p>\n\n      <div class=\"sec-tabs\" style=\"display:flex;gap:8px;margin-bottom:14px;border-bottom:1px solid var(--border);\">\n        <button class=\"dep-tab active\" data-tab=\"services\">Services</button>\n        <button class=\"dep-tab\" data-tab=\"deploy\">Deploy</button>\n        <button class=\"dep-tab\" data-tab=\"journal\">Journal</button><button class=\"dep-tab\" data-tab=\"install\">Install</button>\n      </div>\n\n      <!-- SERVICES TAB -->\n      <div class=\"dep-panel\" data-panel=\"services\">\n        <div id=\"dep-services\" class=\"scroll-container\" style=\"max-height:320px;\">Loading\u2026</div>\n        <div style=\"margin-top:10px;display:flex;gap:8px;align-items:center;\">\n          <input id=\"dep-status-name\" placeholder=\"service name\" style=\"width:220px;\" />\n          <button class=\"btn\" id=\"dep-status-btn\">Check status</button>\n        </div>\n      </div>\n\n      <!-- DEPLOY TAB -->\n      <div class=\"dep-panel\" data-panel=\"deploy\" style=\"display:none;\">\n        <div style=\"display:flex;gap:8px;align-items:center;margin-bottom:10px;\">\n          <select id=\"dep-repo-select\" style=\"min-width:280px;\"><option>Loading\u2026</option></select>\n          <button class=\"btn btn-primary\" id=\"dep-deploy-btn\">Deploy</button>\n        </div>\n        <p class=\"modal-subtitle\">Deploys are serialized fleet-side; a run takes ~30-60s. Output streams below when it finishes.</p>\n      </div>\n\n      <!-- JOURNAL TAB -->\n      <div class=\"dep-panel\" data-panel=\"journal\" style=\"display:none;\">\n        <div style=\"display:flex;gap:8px;align-items:center;margin-bottom:10px;\">\n          <input id=\"dep-journal-name\" placeholder=\"service (empty = all)\" style=\"width:220px;\" />\n          <button class=\"btn\" id=\"dep-journal-btn\">Refresh</button>\n        </div>\n        <div id=\"dep-journal\" class=\"scroll-container\" style=\"max-height:320px;\">Loading\u2026</div>\n      </div>\n\n      <!-- INSTALL TAB (DC-131) -->\n      <div class=\"dep-panel\" data-panel=\"install\" style=\"display:none;\">\n        <div style=\"display:grid;gap:10px;max-width:640px;\">\n          <div style=\"display:grid;gap:4px;\">\n            <span class=\"modal-subtitle\" style=\"margin:0;\">Gitea server (any instance)</span>\n            <div style=\"display:flex;gap:8px;\">\n              <input id=\"dep-gh-gitea-host\" placeholder=\"git.dashcaddy.net (default)\" style=\"flex:1;\" autocomplete=\"off\" spellcheck=\"false\" />\n              <input id=\"dep-gh-gitea-token\" type=\"password\" placeholder=\"token (private repos)\" style=\"flex:1;\" autocomplete=\"off\" spellcheck=\"false\" />\n            </div>\n            <label style=\"display:flex;gap:6px;align-items:center;font-size:12px;\">\n              <input id=\"dep-gh-anonymous\" type=\"checkbox\" />\n              Anonymous \u2014 ignore the saved fleet token for this request\n            </label>\n          </div>\n          <label style=\"display:grid;gap:4px;\">\n            <span class=\"modal-subtitle\" style=\"margin:0;\">Pick a repo</span>\n            <select id=\"dep-gh-gitea\" style=\"min-width:280px;\"><option value=\"\">Loading\u2026</option></select>\n          </label>\n          <label style=\"display:grid;gap:4px;\">\n            <span class=\"modal-subtitle\" style=\"margin:0;\">\u2026or paste any repo URL (GitHub, Gitea, or any https git host)</span>\n            <input id=\"dep-gh-url\" placeholder=\"https://host/owner/repo\" style=\"width:100%;\" />\n          </label>\n          <label style=\"display:grid;gap:4px;\">\n            <span class=\"modal-subtitle\" style=\"margin:0;\">Name (used as subdomain; card title falls back to repo name)</span>\n            <input id=\"dep-gh-service\" placeholder=\"my-app\" style=\"width:220px;\" />\n          </label>\n          <label style=\"display:grid;gap:4px;\">\n            <span class=\"modal-subtitle\" style=\"margin:0;\">Optional launch args (space-separated simple tokens, e.g. -text hi)</span>\n            <input id=\"dep-gh-args\" placeholder=\"-text hello\" style=\"width:100%;\" />\n          </label>\n          <p class=\"modal-subtitle\" style=\"margin:0;\">\n            Go repos with a main package install automatically: build, systemd release,\n            Caddy gate (tailnet-only), DNS, verify, dashboard card. Takes ~30-60s.\n          </p>\n          <div><button class=\"btn btn-primary\" id=\"dep-gh-btn\">Install</button></div>\n        </div>\n      </div>\n      <!-- OUTPUT -->\n      <pre id=\"dep-output\" class=\"scroll-container\" style=\"display:none;max-height:260px;margin-top:12px;background:var(--bg-2,#111);padding:10px;border-radius:8px;white-space:pre-wrap;\"></pre>\n\n      <div style=\"display:flex;justify-content:flex-end;gap:8px;margin-top:14px;\">\n        <button class=\"btn\" id=\"dep-close\">Close</button>\n      </div>\n    </div>\n  </div>`);\n\n  const $ = (id) => document.getElementById(id);\n  let openBtn = null;\n  let loadedOnce = false;\n\n  function esc(s) {\n    return window.escapeHtml ? window.escapeHtml(String(s)) : String(s).replace(/[&<>\"']/g, (c) => ({'&':'&amp;','<':'&lt;','>':'&gt;','\"':'&quot;',\"'\":'&#39;'}[c]));\n  }\n\n  async function api(path, opts) {\n    const r = await fetch('/dashcaddy-api/api/v1/deploys' + path, Object.assign({ credentials: 'include' }, opts || {}));\n    let body = null;\n    try { body = await r.json(); } catch (e) { body = { success: false, error: 'non-JSON response' }; }\n    return { status: r.status, body };\n  }\n\n  function showOutput(text) {\n    const el = $('dep-output');\n    el.style.display = 'block';\n    el.textContent = text || '(no output)';\n    el.scrollTop = el.scrollHeight;\n  }\n\n  async function loadServices() {\n    const el = $('dep-services');\n    const { body } = await api('/services');\n    if (!body.success) {\n      el.innerHTML = '<em>' + esc(body.error || 'unavailable') + '</em>';\n      return;\n    }\n    const rows = body.services || [];\n    if (!rows.length) {\n      el.innerHTML = '<em>No shipdeck deployments on record yet.</em>';\n      return;\n    }\n    el.innerHTML = '<table class=\"table\" style=\"width:100%;\"><thead><tr>' +\n      '<th>Service</th><th>Last action</th><th>When</th><th>Release</th><th></th>' +\n      '</tr></thead><tbody>' +\n      rows.map((s) =>\n        '<tr>' +\n        '<td><strong>' + esc(s.name) + '</strong></td>' +\n        '<td>' + esc(s.last_action) + '</td>' +\n        '<td>' + esc(s.last_time) + '</td>' +\n        '<td>' + esc(s.last_epoch) + '</td>' +\n        '<td><button class=\"btn btn-sm dep-rollback\" data-service=\"' + esc(s.name) + '\">Rollback</button> ' +\n        '<button class=\"btn btn-sm dep-status\" data-service=\"' + esc(s.name) + '\">Status</button></td>' +\n        '</tr>'\n      ).join('') + '</tbody></table>';\n  }\n\n  async function loadRepos() {\n    const sel = $('dep-repo-select');\n    const { body } = await api('/repos');\n    if (!body.success) {\n      sel.innerHTML = '<option>' + esc(body.error || 'unavailable') + '</option>';\n      return;\n    }\n    const repos = body.repos || [];\n    sel.innerHTML = repos.length\n      ? repos.map((r) => '<option value=\"' + esc(r.dir) + '\">' + esc(r.name) + '</option>').join('')\n      : '<option value=\"\">(no repos with a Shipdeckfile found)</option>';\n  }\n\n  async function loadJournal(service) {\n    const el = $('dep-journal');\n    const qs = service ? '?service=' + encodeURIComponent(service) : '';\n    const { body } = await api('/journal' + qs);\n    const rows = (body.rows || []);\n    if (!rows.length) {\n      el.innerHTML = '<em>No journal rows.</em>';\n      return;\n    }\n    el.innerHTML = '<table class=\"table\" style=\"width:100%;\"><thead><tr>' +\n      '<th>Time</th><th>Service</th><th>Action</th><th>Release</th><th>Duration</th>' +\n      '</tr></thead><tbody>' +\n      rows.map((r) =>\n        '<tr><td>' + esc(r.time) + '</td><td>' + esc(r.service) + '</td><td>' + esc(r.action) +\n        '</td><td>' + esc(r.epoch) + '</td><td>' + esc(r.duration || '\u2014') + '</td></tr>'\n      ).join('') + '</tbody></table>';\n  }\n\n\n\n  async function loadGiteaRepos() {\n    const sel = document.getElementById('dep-gh-gitea');\n    const hostEl = document.getElementById('dep-gh-gitea-host');\n    const tokEl = document.getElementById('dep-gh-gitea-token');\n    const anonEl = document.getElementById('dep-gh-anonymous');\n    const payload = {};\n    if (hostEl && hostEl.value.trim()) payload.gitea_url = 'https://' + hostEl.value.trim().replace(/^https?:\\/*/, '');\n    // Distinguish omitted (fleet fallback allowed) from explicit anonymous\n    // (empty token preserved on wire). A non-empty user token wins.\n    if (anonEl && anonEl.checked) payload.token = '';\n    else {\n      const t = window.__dc133_requestToken(false, tokEl && tokEl.value);\n      if (t !== undefined) payload.token = t;\n    }\n    try {\n      const { status, body } = await api('/gitea-repos', {\n        method: 'POST',\n        headers: { 'Content-Type': 'application/json' },\n        body: JSON.stringify(payload),\n      });\n      if (!body.success || !(body.repos || []).length) {\n        sel.innerHTML = '<option value=\"\">' + esc(body.error || 'no repos found') + '</option>';\n        return;\n      }\n      // All remote fields are untrusted (hostile Gitea instance or repo\n      // metadata) \u2014 build options through the escaping helper (pinned by\n      // status/tests/deploys-install.test.js).\n      sel.innerHTML = window.__dc133_buildRepoOptions(body.repos, esc);\n    } catch (e) {\n      sel.innerHTML = '<option value=\"\">unavailable</option>';\n    }\n  }\n\n  async function runInstall() {\n    const btn = document.getElementById('dep-gh-btn');\n    const repoUrl = document.getElementById('dep-gh-url').value.trim();\n    const service = (document.getElementById('dep-gh-service').value.trim() || '').toLowerCase();\n    const argsRaw = document.getElementById('dep-gh-args').value.trim();\n    if (!repoUrl || !service) { showOutput('Repo URL and name are required.'); return; }\n    const args = argsRaw ? argsRaw.split(/\\s+/) : [];\n    setBusy(true, btn, 'Install');\n    showOutput('Installing ' + repoUrl + '\\nCloning, building, gating and DNS-ing... (~30-60s)');\n    try {\n      const anonymous = !!(document.getElementById('dep-gh-anonymous') || {}).checked;\n      const typedToken = (document.getElementById('dep-gh-gitea-token') || { value: '' }).value;\n      const requestToken = window.__dc133_requestToken(anonymous, typedToken);\n      const { status, body } = await api('/install', {\n        method: 'POST',\n        headers: { 'Content-Type': 'application/json' },\n        body: JSON.stringify({ repo_url: repoUrl, service, args,\n          token: requestToken }),\n      });\n      if (!body.success) {\n        showOutput((body.output ? body.output + '\\n' : '') + 'FAIL ' + (body.error || ('HTTP ' + status)));\n        setBusy(false, btn, 'Install');\n        return;\n      }\n      const svc = body.service || {};\n      const exists = (window.APPS || []).some((a) => a.id === svc.id);\n      if (!exists) {\n        const card = { id: svc.id, name: svc.name || svc.id, url: svc.url, logo: svc.logo, tailscaleOnly: true, isCustom: true };\n        try {\n          await fetch('/dashcaddy-api/api/v1/services', {\n            method: 'POST',\n            credentials: 'include',\n            headers: { 'Content-Type': 'application/json' },\n            body: JSON.stringify(card),\n          });\n          window.APPS.push(card);\n          if (typeof window.renderApps === 'function') window.renderApps();\n          if (typeof window.renderGrid === 'function') window.renderGrid();\n        } catch (e) { /* card registration best-effort */ }\n      }\n      showOutput('INSTALLED ' + (svc.name || svc.id) + ' in ' + (svc.deploy_seconds || '?') + 's' +\n        '\\nCard: ' + (svc.url || '') +\n        '\\n' + (body.output || '').slice(-800));\n      loadServices();\n    } catch (e) {\n      showOutput('install error: ' + e.message);\n    }\n    setBusy(false, btn, 'Install');\n  }\n\n  function setBusy(busy, btn, label) {\n    if (!btn) return;\n    btn.disabled = busy;\n    if (label) btn.textContent = busy ? 'Working\u2026' : label;\n  }\n\n  async function runDeploy() {\n    const btn = $('dep-deploy-btn');\n    const dir = $('dep-repo-select').value;\n    if (!dir) return;\n    setBusy(true, btn, 'Deploy');\n    showOutput('Deploying ' + dir + '\\nThis can take ~30-60s\u2026');\n    try {\n      const { body } = await api('/deploy', {\n        method: 'POST',\n        headers: { 'Content-Type': 'application/json' },\n        body: JSON.stringify({ dir }),\n      });\n      showOutput((body.output || body.error || '') + (body.success ? '\\n\u2705 SUCCESS' : '\\n\u274C FAILED'));\n      loadServices();\n    } catch (e) {\n      showOutput('deploy error: ' + e.message);\n    }\n    setBusy(false, btn, 'Deploy');\n  }\n\n  async function runRollback(service, btn) {\n    if (!confirm('Roll back ' + service + ' to the previous release?')) return;\n    setBusy(true, btn, 'Rollback');\n    showOutput('Rolling back ' + service + '\u2026');\n    try {\n      const { body } = await api('/rollback', {\n        method: 'POST',\n        headers: { 'Content-Type': 'application/json' },\n        body: JSON.stringify({ service }),\n      });\n      showOutput((body.output || body.error || '') + (body.success ? '\\n\u2705 ROLLED BACK' : '\\n\u274C FAILED'));\n      loadServices();\n    } catch (e) {\n      showOutput('rollback error: ' + e.message);\n    }\n    setBusy(false, btn, 'Rollback');\n  }\n\n  async function runStatus(service, btn) {\n    setBusy(true, btn, 'Status');\n    try {\n      const { body } = await api('/status?service=' + encodeURIComponent(service));\n      showOutput(body.output || body.error || '(no output)');\n    } catch (e) {\n      showOutput('status error: ' + e.message);\n    }\n    setBusy(false, btn, 'Status');\n  }\n\n  function wire() {\n    openBtn = document.getElementById('deploys-btn');\n    if (!openBtn) return;\n\n    openBtn.addEventListener('click', async () => {\n      $('deploys-modal').classList.add('open');\n      if (!loadedOnce) {\n        loadedOnce = true;\n        loadServices();\n        loadRepos();\n        loadJournal('');\n        loadGiteaRepos();\n      }\n    });\n\n    $('dep-close').addEventListener('click', () => {\n      $('deploys-modal').classList.remove('open');\n    });\n\n    // tab switching\n    document.querySelectorAll('.dep-tab').forEach((tab) => {\n      tab.addEventListener('click', () => {\n        document.querySelectorAll('.dep-tab').forEach((t) => t.classList.remove('active'));\n        tab.classList.add('active');\n        document.querySelectorAll('#deploys-modal .dep-panel').forEach((p) => {\n          p.style.display = p.dataset.panel === tab.dataset.tab ? 'block' : 'none';\n        });\n      });\n    });\n\n    $('dep-deploy-btn').addEventListener('click', runDeploy);\n    $('dep-gh-btn').addEventListener('click', runInstall);\n    ['dep-gh-gitea-host', 'dep-gh-gitea-token'].forEach((id) => {\n      const el = document.getElementById(id);\n      if (el) el.addEventListener('change', () => loadGiteaRepos());\n    });\n    document.getElementById('dep-gh-gitea').addEventListener('change', (e) => {\n      const v = e.target.value;\n      if (v) {\n        document.getElementById('dep-gh-url').value = v;\n        const opt = e.target.selectedOptions[0];\n        const id = opt && opt.dataset ? opt.dataset.id : '';\n        const svc = document.getElementById('dep-gh-service');\n        if (id && !svc.value) svc.value = id;\n      }\n    });\n\n\n    $('dep-journal-btn').addEventListener('click', () => loadJournal($('dep-journal-name').value.trim()));\n    $('dep-status-btn').addEventListener('click', () => {\n      const name = $('dep-status-name').value.trim();\n      if (name) runStatus(name);\n    });\n\n    // dynamic buttons (service table)\n    $('dep-services').addEventListener('click', (e) => {\n      const rb = e.target.closest('.dep-rollback');\n      if (rb) return runRollback(rb.dataset.service, rb);\n      const sb = e.target.closest('.dep-status');\n      if (sb) return runStatus(sb.dataset.service, sb);\n    });\n  }\n\n  if (document.readyState === 'loading') {\n    document.addEventListener('DOMContentLoaded', wire);\n  } else {\n    wire();\n  }\n})();\n;\n// ========== WEATHER WIDGET ==========\n(function() {\n  const errorHandler = new ErrorHandler();\n  // Inject modal HTML\n  injectModal('weather-modal', `<div id=\"weather-modal\" class=\"weather-modal\"><div class=\"weather-modal-content\"><h3>Weather Settings</h3>\n    <label for=\"weather-location-input\">Location:</label>\n    <input type=\"text\" id=\"weather-location-input\" placeholder=\"City name or ZIP (e.g., Hamburg, 90210)\" maxlength=\"100\">\n    <div style=\"font-size: 0.78rem; color: var(--muted); margin-top: 4px;\">Enter a city name, postal code, or &ldquo;City, Country&rdquo;</div>\n    <div style=\"margin-top: 14px; padding-top: 12px; border-top: 1px solid var(--border);\">\n      <label style=\"display: block; margin-bottom: 8px; font-weight: 600; color: var(--fg);\">Units</label>\n      <div style=\"display: flex; gap: 8px;\">\n        <label class=\"weather-unit-option\"><input type=\"radio\" name=\"weather-unit-radio\" value=\"imperial\"><span class=\"weather-unit-card\">&deg;F / mph</span></label>\n        <label class=\"weather-unit-option\"><input type=\"radio\" name=\"weather-unit-radio\" value=\"metric\"><span class=\"weather-unit-card\">&deg;C / km/h</span></label>\n      </div>\n    </div>\n    <div class=\"weather-modal-buttons\"><button id=\"weather-cancel\">Cancel</button><button id=\"weather-save\">Save</button></div></div></div>`);\n\n  /* Weather Widget \u2014 powered by Open-Meteo (free, no API key) */\n  const LOCATION_KEY = 'weather-location';\n  const LEGACY_KEY = 'weather-zip';\n  const GEO_CACHE_KEY = 'weather-geo';\n  const UNIT_KEY = 'weather-unit';\n\n  // Migrate from old ZIP-only key\n  if (!safeGet(LOCATION_KEY) && safeGet(LEGACY_KEY)) {\n    safeSet(LOCATION_KEY, safeGet(LEGACY_KEY));\n  }\n\n  function getUnit() {\n    return safeGet(UNIT_KEY) || 'imperial';\n  }\n\n  function getWeatherElements() {\n    return {\n      icon: document.querySelector('.weather-icon'),\n      temp: document.querySelector('.weather-temp'),\n      condition: document.querySelector('.weather-condition'),\n      location: document.querySelector('.weather-location'),\n      wind: document.querySelector('.weather-wind')\n    };\n  }\n\n  // WMO Weather Code mapping\n  const wmoDescriptions = {\n    0: 'Clear sky', 1: 'Mainly clear', 2: 'Partly cloudy', 3: 'Overcast',\n    45: 'Fog', 48: 'Rime fog',\n    51: 'Light drizzle', 53: 'Drizzle', 55: 'Dense drizzle',\n    56: 'Freezing drizzle', 57: 'Dense freezing drizzle',\n    61: 'Light rain', 63: 'Moderate rain', 65: 'Heavy rain',\n    66: 'Light freezing rain', 67: 'Heavy freezing rain',\n    71: 'Light snow', 73: 'Moderate snow', 75: 'Heavy snow', 77: 'Snow grains',\n    80: 'Light showers', 81: 'Moderate showers', 82: 'Violent showers',\n    85: 'Light snow showers', 86: 'Heavy snow showers',\n    95: 'Thunderstorm', 96: 'Thunderstorm with hail', 99: 'Severe thunderstorm'\n  };\n\n  const wmoIcons = {\n    0: '\u2600\uFE0F', 1: '\uD83C\uDF24\uFE0F', 2: '\u26C5', 3: '\u2601\uFE0F',\n    45: '\uD83C\uDF2B\uFE0F', 48: '\uD83C\uDF2B\uFE0F',\n    51: '\uD83C\uDF26\uFE0F', 53: '\uD83C\uDF26\uFE0F', 55: '\uD83C\uDF26\uFE0F',\n    56: '\uD83C\uDF28\uFE0F', 57: '\uD83C\uDF28\uFE0F',\n    61: '\uD83C\uDF26\uFE0F', 63: '\uD83C\uDF27\uFE0F', 65: '\uD83C\uDF27\uFE0F',\n    66: '\uD83C\uDF28\uFE0F', 67: '\uD83C\uDF28\uFE0F',\n    71: '\uD83C\uDF28\uFE0F', 73: '\u2744\uFE0F', 75: '\u2744\uFE0F', 77: '\u2744\uFE0F',\n    80: '\uD83C\uDF26\uFE0F', 81: '\uD83C\uDF27\uFE0F', 82: '\uD83C\uDF27\uFE0F',\n    85: '\uD83C\uDF28\uFE0F', 86: '\u2744\uFE0F',\n    95: '\u26C8\uFE0F', 96: '\u26C8\uFE0F', 99: '\u26C8\uFE0F'\n  };\n\n  // Wind direction from degrees\n  const windDirs = ['N','NNE','NE','ENE','E','ESE','SE','SSE','S','SSW','SW','WSW','W','WNW','NW','NNW'];\n  function degToDir(deg) {\n    return windDirs[Math.round(deg / 22.5) % 16];\n  }\n\n  // Geocode location via Open-Meteo, with localStorage cache\n  async function geocodeLocation(query) {\n    const cached = safeGet(GEO_CACHE_KEY);\n    if (cached) {\n      try {\n        const geo = JSON.parse(cached);\n        if (geo.query === query) return geo;\n      } catch {}\n    }\n    const resp = await fetch(`https://geocoding-api.open-meteo.com/v1/search?name=${encodeURIComponent(query)}&count=1&language=en&format=json`);\n    if (!resp.ok) throw new Error('Geocoding failed');\n    const data = await resp.json();\n    if (!data.results || !data.results.length) throw new Error('Location not found');\n    const r = data.results[0];\n    const geo = {\n      query,\n      lat: r.latitude,\n      lon: r.longitude,\n      city: r.name,\n      state: r.admin1 || '',\n      country: r.country || '',\n      countryCode: r.country_code || ''\n    };\n    safeSet(GEO_CACHE_KEY, JSON.stringify(geo));\n    return geo;\n  }\n\n  function formatLocation(geo) {\n    // For US locations show \"City, State\", for others show \"City, Country\"\n    if (geo.countryCode === 'US' && geo.state) {\n      return `${geo.city}, ${geo.state}`;\n    }\n    if (geo.country) {\n      return `${geo.city}, ${geo.country}`;\n    }\n    return geo.city;\n  }\n\n  async function fetchWeather(location) {\n    try {\n      const geo = await geocodeLocation(location);\n      const unit = getUnit();\n      const tempUnit = unit === 'metric' ? 'celsius' : 'fahrenheit';\n      const windUnit = unit === 'metric' ? 'kmh' : 'mph';\n      const url = `https://api.open-meteo.com/v1/forecast?latitude=${geo.lat}&longitude=${geo.lon}&current=temperature_2m,weather_code,wind_speed_10m,wind_direction_10m&temperature_unit=${tempUnit}&wind_speed_unit=${windUnit}`;\n      const resp = await fetch(url);\n      if (!resp.ok) throw new Error('Weather fetch failed');\n      const data = await resp.json();\n      const c = data.current;\n      const code = c.weather_code;\n      return {\n        temp: Math.round(c.temperature_2m),\n        condition: wmoDescriptions[code] || 'Unknown',\n        icon: wmoIcons[code] || '\uD83C\uDF24\uFE0F',\n        locationStr: formatLocation(geo),\n        windSpeed: Math.round(c.wind_speed_10m),\n        windDir: degToDir(c.wind_direction_10m),\n        unit\n      };\n    } catch (error) {\n      console.warn('Weather fetch failed:', error);\n      return null;\n    }\n  }\n\n  async function updateWeather() {\n    const weatherWidget = getWeatherElements();\n    if (!weatherWidget.icon || !weatherWidget.temp || !weatherWidget.condition || !weatherWidget.location || !weatherWidget.wind) {\n      console.warn('Weather widget elements not found');\n      return;\n    }\n\n    const location = safeGet(LOCATION_KEY);\n    if (!location) {\n      weatherWidget.location.textContent = 'Set Location';\n      weatherWidget.temp.textContent = '--\\u00B0';\n      weatherWidget.condition.textContent = 'Click \\u2699\\uFE0F to configure';\n      weatherWidget.wind.textContent = '--';\n      weatherWidget.icon.innerHTML = '<span class=\"weather-emoji\">\\uD83C\\uDF24\\uFE0F</span>';\n      return;\n    }\n\n    try {\n      const weather = await fetchWeather(location);\n      if (weather) {\n        const tempSuffix = weather.unit === 'metric' ? '\\u00B0C' : '\\u00B0F';\n        const windLabel = weather.unit === 'metric' ? 'km/h' : 'mph';\n        weatherWidget.location.textContent = weather.locationStr;\n        weatherWidget.temp.textContent = `${weather.temp}${tempSuffix}`;\n        weatherWidget.condition.textContent = weather.condition;\n        weatherWidget.wind.textContent = `Wind: ${weather.windSpeed} ${windLabel} ${weather.windDir}`;\n        weatherWidget.icon.innerHTML = `<span class=\"weather-emoji\">${escapeHtml(weather.icon)}</span>`;\n      }\n    } catch (error) {\n      errorHandler.logError('[Weather] Update Error', error, { function: 'updateWeather' });\n      weatherWidget.location.textContent = 'Weather Error';\n      weatherWidget.temp.textContent = 'Error';\n      weatherWidget.condition.textContent = 'Failed to load';\n      weatherWidget.wind.textContent = '--';\n    }\n  }\n\n  // Weather settings modal\n  const modal = document.getElementById('weather-modal');\n  const locationInput = document.getElementById('weather-location-input');\n\n  document.getElementById('weather-settings')?.addEventListener('click', () => {\n    locationInput.value = safeGet(LOCATION_KEY) || '';\n    // Set unit radio\n    const unit = getUnit();\n    const radio = modal.querySelector(`input[name=\"weather-unit-radio\"][value=\"${unit}\"]`);\n    if (radio) radio.checked = true;\n    modal.classList.add('show');\n    locationInput.focus();\n  });\n\n  document.getElementById('weather-cancel')?.addEventListener('click', () => {\n    modal.classList.remove('show');\n  });\n\n  document.getElementById('weather-save')?.addEventListener('click', () => {\n    const loc = locationInput.value.trim();\n    if (loc) {\n      // Clear geo cache when location changes so it re-geocodes\n      const oldLoc = safeGet(LOCATION_KEY);\n      if (oldLoc !== loc) safeSet(GEO_CACHE_KEY, '');\n      safeSet(LOCATION_KEY, loc);\n      // Save unit preference\n      const unitRadio = modal.querySelector('input[name=\"weather-unit-radio\"]:checked');\n      const newUnit = unitRadio ? unitRadio.value : 'imperial';\n      const oldUnit = getUnit();\n      safeSet(UNIT_KEY, newUnit);\n      // Clear geo cache if unit changed (need fresh weather data)\n      if (oldUnit !== newUnit) safeSet(GEO_CACHE_KEY, '');\n      modal.classList.remove('show');\n      updateWeather();\n    } else {\n      showNotification('Please enter a location (e.g., Hamburg, London, 90210)', 'warning');\n    }\n  });\n\n  wireModal(modal);\n\n  // Close modal on Escape key\n  document.addEventListener('keydown', (e) => {\n    if (e.key === 'Escape' && modal.classList.contains('show')) {\n      modal.classList.remove('show');\n    }\n  });\n\n  // Initialize weather\n  updateWeather();\n  // Update weather every 10 minutes\n  setInterval(updateWeather, DC.POLL.WEATHER);\n})();\n;\n// ========== DIGITAL CLOCK WIDGET ==========\n(function() {\n  const widget = document.getElementById('clock-widget');\n  const render = document.getElementById('clock-render');\n  if (!widget || !render) return;\n\n  const DAYS = ['Sunday','Monday','Tuesday','Wednesday','Thursday','Friday','Saturday'];\n  const MONTHS = ['January','February','March','April','May','June','July','August','September','October','November','December'];\n  const ROMAN = ['XII','I','II','III','IV','V','VI','VII','VIII','IX','X','XI'];\n\n  let currentStyle = safeGet('clock-style') || 'default';\n  let lastChimeHour = -1;\n  let chimePlaying = false;\n  let prevFlipDigits = '';\n  let activeLayout = '';\n  let digitalRefs = null;\n  let tickTimer = null;\n\n  // ===== CHIMES =====\n  function playChimes(count) {\n    if (chimePlaying) return;\n    if (safeGet('clock-chimes') !== 'true') return;\n    chimePlaying = true;\n    const vol = parseInt(safeGet('clock-chime-volume') || '50', 10) / 100;\n    let i = 0;\n    function strike() {\n      if (i >= count) { chimePlaying = false; return; }\n      const bell = new Audio('/assets/sounds/church-bell.mp3');\n      bell.volume = vol;\n      bell.play().catch(() => {});\n      i++;\n      if (i < count) setTimeout(strike, 2500);\n      else setTimeout(() => { chimePlaying = false; }, 2500);\n    }\n    strike();\n  }\n\n  // ===== DATE STRING =====\n  function dateStr(now) {\n    return DAYS[now.getDay()] + ', ' + MONTHS[now.getMonth()] + ' ' + now.getDate() + ', ' + now.getFullYear();\n  }\n\n  function resetRenderLayout() {\n    activeLayout = '';\n    digitalRefs = null;\n  }\n\n  function ensureDigitalLayout() {\n    if (activeLayout !== 'digital') {\n      render.innerHTML =\n        '<div class=\"clock-time\"><span class=\"clock-main\"></span><span class=\"clock-seconds\"></span><span class=\"clock-ampm\"></span></div>' +\n        '<div class=\"clock-date\"></div>';\n      digitalRefs = {\n        main: render.querySelector('.clock-main'),\n        seconds: render.querySelector('.clock-seconds'),\n        ampm: render.querySelector('.clock-ampm'),\n        date: render.querySelector('.clock-date')\n      };\n      activeLayout = 'digital';\n    }\n    return digitalRefs;\n  }\n\n  // ===== STYLE RENDERERS =====\n\n  function renderDefault(now) {\n    const h24 = now.getHours(), m = now.getMinutes(), s = now.getSeconds();\n    const ampm = h24 >= 12 ? 'PM' : 'AM';\n    const h = h24 % 12 || 12;\n    const refs = ensureDigitalLayout();\n    refs.main.textContent = `${h}:${String(m).padStart(2,'0')}`;\n    refs.seconds.textContent = `:${String(s).padStart(2,'0')}`;\n    refs.ampm.textContent = ampm;\n    refs.date.textContent = dateStr(now);\n  }\n\n  function renderLcd(now, cls) {\n    const h24 = now.getHours(), m = now.getMinutes(), s = now.getSeconds();\n    const ampm = h24 >= 12 ? 'PM' : 'AM';\n    const h = h24 % 12 || 12;\n    const refs = ensureDigitalLayout();\n    refs.main.textContent = `${String(h).padStart(2,'0')}:${String(m).padStart(2,'0')}`;\n    refs.seconds.textContent = `:${String(s).padStart(2,'0')}`;\n    refs.ampm.textContent = ampm;\n    refs.date.textContent = dateStr(now);\n  }\n\n  function renderFlip(now) {\n    const h24 = now.getHours(), m = now.getMinutes(), s = now.getSeconds();\n    const ampm = h24 >= 12 ? 'PM' : 'AM';\n    const h = h24 % 12 || 12;\n    const digits = String(h).padStart(2,' ') + String(m).padStart(2,'0') + String(s).padStart(2,'0');\n\n    let html = '<div class=\"flip-clock-row\">';\n    // Hours\n    html += flipCard(digits[0], 0);\n    html += flipCard(digits[1], 1);\n    html += '<span class=\"flip-colon\">:</span>';\n    // Minutes\n    html += flipCard(digits[2], 2);\n    html += flipCard(digits[3], 3);\n    html += '<span class=\"flip-colon\">:</span>';\n    // Seconds\n    html += flipCard(digits[4], 4);\n    html += flipCard(digits[5], 5);\n    html += `<span class=\"flip-ampm\">${ampm}</span>`;\n    html += '</div>';\n    html += `<div class=\"clock-date\">${dateStr(now)}</div>`;\n    render.innerHTML = html;\n    activeLayout = 'flip';\n\n    // Trigger flip animation on changed digits\n    if (prevFlipDigits) {\n      for (let i = 0; i < 6; i++) {\n        if (digits[i] !== prevFlipDigits[i]) {\n          const card = render.querySelector(`.flip-card[data-idx=\"${i}\"]`);\n          if (card) card.classList.add('flipping');\n        }\n      }\n    }\n    prevFlipDigits = digits;\n  }\n\n  function flipCard(digit, idx) {\n    const d = digit === ' ' ? '' : digit;\n    return `<div class=\"flip-card\" data-idx=\"${idx}\"><div class=\"flip-top\">${d}</div><div class=\"flip-bottom\">${d}</div></div>`;\n  }\n\n  function renderBinary(now) {\n    const h24 = now.getHours(), m = now.getMinutes(), s = now.getSeconds();\n    const h = h24 % 12 || 12;\n    const ampm = h24 >= 12 ? 'PM' : 'AM';\n    // 6 columns: H tens, H ones, M tens, M ones, S tens, S ones\n    const cols = [\n      Math.floor(h / 10), h % 10,\n      Math.floor(m / 10), m % 10,\n      Math.floor(s / 10), s % 10\n    ];\n\n    let html = '<div class=\"binary-clock\">';\n    // Labels\n    html += '<div class=\"binary-labels\"><span>H</span><span>H</span><span>M</span><span>M</span><span>S</span><span>S</span></div>';\n    // 4 rows for bits 8,4,2,1\n    for (let bit = 3; bit >= 0; bit--) {\n      html += '<div class=\"binary-row\">';\n      for (let col = 0; col < 6; col++) {\n        const on = (cols[col] >> bit) & 1;\n        html += `<div class=\"binary-dot ${on ? 'on' : ''}\"></div>`;\n      }\n      html += '</div>';\n    }\n    // Value row\n    html += '<div class=\"binary-values\">';\n    for (let col = 0; col < 6; col++) {\n      html += `<span>${cols[col]}</span>`;\n    }\n    html += '</div>';\n    html += `<div class=\"binary-ampm\">${ampm}</div>`;\n    html += '</div>';\n    html += `<div class=\"clock-date\">${dateStr(now)}</div>`;\n    render.innerHTML = html;\n    activeLayout = 'binary';\n  }\n\n  function renderAnalog(now, useRoman) {\n    const h = now.getHours(), m = now.getMinutes(), s = now.getSeconds();\n    const size = 120;\n    const cx = size / 2, cy = size / 2;\n\n    // Angles\n    const sAngle = (s / 60) * 360 - 90;\n    const mAngle = ((m + s / 60) / 60) * 360 - 90;\n    const hAngle = (((h % 12) + m / 60) / 12) * 360 - 90;\n\n    // Number labels\n    let labels = '';\n    for (let i = 1; i <= 12; i++) {\n      const angle = (i / 12) * 2 * Math.PI - Math.PI / 2;\n      const r = 47;\n      const x = cx + r * Math.cos(angle);\n      const y = cy + r * Math.sin(angle);\n      const label = useRoman ? ROMAN[i % 12] : i;\n      const fs = useRoman ? '7' : '9';\n      labels += `<text x=\"${x}\" y=\"${y}\" text-anchor=\"middle\" dominant-baseline=\"central\" fill=\"var(--fg)\" font-size=\"${fs}\" font-weight=\"600\" font-family=\"'Sami Grotesk',sans-serif\">${label}</text>`;\n    }\n\n    // Tick marks\n    let ticks = '';\n    for (let i = 0; i < 60; i++) {\n      const angle = (i / 60) * 2 * Math.PI - Math.PI / 2;\n      const outer = 56;\n      const inner = i % 5 === 0 ? 52 : 54;\n      const x1 = cx + inner * Math.cos(angle);\n      const y1 = cy + inner * Math.sin(angle);\n      const x2 = cx + outer * Math.cos(angle);\n      const y2 = cy + outer * Math.sin(angle);\n      const w = i % 5 === 0 ? 1.5 : 0.5;\n      ticks += `<line x1=\"${x1}\" y1=\"${y1}\" x2=\"${x2}\" y2=\"${y2}\" stroke=\"var(--muted)\" stroke-width=\"${w}\" stroke-linecap=\"round\"/>`;\n    }\n\n    const svg = `<svg class=\"analog-clock-svg\" viewBox=\"0 0 ${size} ${size}\" width=\"${size}\" height=\"${size}\">\n      <circle cx=\"${cx}\" cy=\"${cy}\" r=\"58\" fill=\"none\" stroke=\"var(--border)\" stroke-width=\"2\"/>\n      ${ticks}\n      ${labels}\n      <line x1=\"${cx}\" y1=\"${cy}\" x2=\"${cx + 28 * Math.cos(hAngle * Math.PI / 180)}\" y2=\"${cy + 28 * Math.sin(hAngle * Math.PI / 180)}\" stroke=\"var(--fg)\" stroke-width=\"3\" stroke-linecap=\"round\"/>\n      <line x1=\"${cx}\" y1=\"${cy}\" x2=\"${cx + 38 * Math.cos(mAngle * Math.PI / 180)}\" y2=\"${cy + 38 * Math.sin(mAngle * Math.PI / 180)}\" stroke=\"var(--fg)\" stroke-width=\"2\" stroke-linecap=\"round\"/>\n      <line x1=\"${cx}\" y1=\"${cy}\" x2=\"${cx + 42 * Math.cos(sAngle * Math.PI / 180)}\" y2=\"${cy + 42 * Math.sin(sAngle * Math.PI / 180)}\" stroke=\"#e74c3c\" stroke-width=\"1\" stroke-linecap=\"round\"/>\n      <circle cx=\"${cx}\" cy=\"${cy}\" r=\"3\" fill=\"var(--fg)\"/>\n    </svg>`;\n\n    const ampm = now.getHours() >= 12 ? 'PM' : 'AM';\n    render.innerHTML = `<div class=\"analog-clock-wrap\">${svg}<div class=\"analog-info\"><span class=\"analog-digital\">${(now.getHours() % 12 || 12)}:${String(m).padStart(2,'0')} ${ampm}</span><span class=\"analog-date-sm\">${dateStr(now)}</span></div></div>`;\n    activeLayout = 'analog';\n  }\n\n  // ===== MAIN TICK =====\n  function tick() {\n    const now = new Date();\n    const h = now.getHours() % 12 || 12;\n    const m = now.getMinutes();\n    const s = now.getSeconds();\n\n    // Set style class on widget\n    const nextClassName = 'clock-widget' + (currentStyle !== 'default' ? ' ' + currentStyle : '');\n    if (widget.className !== nextClassName) {\n      widget.className = nextClassName;\n    }\n\n    switch (currentStyle) {\n      case 'lcd': renderLcd(now); break;\n      case 'lcd-blue': renderLcd(now); break;\n      case 'lcd-amber': renderLcd(now); break;\n      case 'lcd-retro': renderLcd(now); break;\n      case 'lcd-taxi': renderLcd(now); break;\n      case 'flip': renderFlip(now); break;\n      case 'binary': renderBinary(now); break;\n      case 'analog': renderAnalog(now, false); break;\n      case 'roman': renderAnalog(now, true); break;\n      default: renderDefault(now);\n    }\n\n    // Hourly chimes\n    if (m === 0 && s === 0 && h !== lastChimeHour) {\n      lastChimeHour = h;\n      playChimes(h);\n    }\n    if (m !== 0) lastChimeHour = -1;\n  }\n\n  function scheduleNextTick() {\n    clearTimeout(tickTimer);\n    const interval = document.hidden ? 60000 : 1000;\n    const delay = interval - (Date.now() % interval) + 25;\n    tickTimer = setTimeout(() => {\n      tick();\n      scheduleNextTick();\n    }, delay);\n  }\n\n  document.addEventListener('visibilitychange', () => {\n    prevFlipDigits = '';\n    resetRenderLayout();\n    tick();\n    scheduleNextTick();\n  });\n\n  tick();\n  scheduleNextTick();\n\n  // ===== SETTINGS MODAL =====\n  const STYLES = [\n    { id: 'default', label: 'Default', icon: '\uD83D\uDD50' },\n    { id: 'lcd', label: 'LCD Green', icon: '\uD83D\uDC9A' },\n    { id: 'lcd-blue', label: 'LCD Blue', icon: '\uD83D\uDC99' },\n    { id: 'lcd-amber', label: 'LCD Amber', icon: '\uD83D\uDFE0' },\n    { id: 'lcd-retro', label: 'LCD Retro', icon: '\uD83D\uDFE9' },\n    { id: 'lcd-taxi', label: 'LCD Taxi', icon: '\uD83D\uDFE1' },\n    { id: 'flip', label: 'Flip Clock', icon: '\uD83D\uDCDF' },\n    { id: 'binary', label: 'Binary', icon: '\uD83D\uDCBB' },\n    { id: 'analog', label: 'Analog', icon: '\u23F0' },\n    { id: 'roman', label: 'Roman', icon: '\uD83C\uDFDB\uFE0F' },\n  ];\n\n  let styleOptionsHtml = '<div class=\"clock-style-grid\">';\n  STYLES.forEach(s => {\n    styleOptionsHtml += `<label class=\"clock-style-option\">\n      <input type=\"radio\" name=\"clock-style-radio\" value=\"${s.id}\">\n      <span class=\"clock-style-card\"><span class=\"clock-style-icon\">${s.icon}</span><span class=\"clock-style-label\">${s.label}</span></span>\n    </label>`;\n  });\n  styleOptionsHtml += '</div>';\n\n  injectModal('clock-settings-modal', `<div id=\"clock-settings-modal\" class=\"weather-modal\">\n    <div class=\"weather-modal-content\" style=\"max-width: 420px;\">\n      <h3>Clock Settings</h3>\n      <div style=\"margin-bottom: 16px;\">\n        <label style=\"display: block; margin-bottom: 8px; font-weight: 600; color: var(--fg);\">Style</label>\n        ${styleOptionsHtml}\n      </div>\n      <div style=\"margin-bottom: 16px; padding-top: 12px; border-top: 1px solid var(--border);\">\n        <label style=\"display: flex; align-items: center; gap: 8px; cursor: pointer; font-weight: 600; color: var(--fg);\">\n          <input type=\"checkbox\" id=\"clock-chimes-toggle\"> Hourly church bell chimes\n        </label>\n        <div style=\"font-size: 0.78rem; color: var(--muted); margin-top: 4px; margin-left: 24px;\">\n          Strikes the number of the hour (e.g., 3 bells at 3:00)\n        </div>\n      </div>\n      <div style=\"margin-bottom: 16px;\" id=\"clock-volume-section\">\n        <label style=\"display: block; margin-bottom: 6px; font-weight: 600; color: var(--fg);\">Volume</label>\n        <div style=\"display: flex; align-items: center; gap: 10px;\">\n          <span style=\"font-size: 0.85rem;\">\uD83D\uDD08</span>\n          <input type=\"range\" id=\"clock-chime-volume\" min=\"0\" max=\"100\" value=\"50\" style=\"flex: 1; accent-color: var(--ok-fg);\">\n          <span style=\"font-size: 0.85rem;\">\uD83D\uDD0A</span>\n          <button id=\"clock-chime-test\" style=\"padding: 4px 10px; font-size: 0.78rem; border-radius: 4px; cursor: pointer;\">Test</button>\n        </div>\n      </div>\n      <div class=\"weather-modal-buttons\">\n        <button id=\"clock-settings-cancel\">Cancel</button>\n        <button id=\"clock-settings-save\">Save</button>\n      </div>\n    </div>\n  </div>`);\n\n  const modal = document.getElementById('clock-settings-modal');\n  const chimesToggle = document.getElementById('clock-chimes-toggle');\n  const volumeSlider = document.getElementById('clock-chime-volume');\n  const volumeSection = document.getElementById('clock-volume-section');\n\n  function loadSettings() {\n    const style = safeGet('clock-style') || 'default';\n    const radio = modal.querySelector(`input[value=\"${style}\"]`);\n    if (radio) radio.checked = true;\n    chimesToggle.checked = safeGet('clock-chimes') === 'true';\n    volumeSlider.value = safeGet('clock-chime-volume') || '50';\n    volumeSection.style.opacity = chimesToggle.checked ? '1' : '0.4';\n  }\n\n  chimesToggle?.addEventListener('change', () => {\n    volumeSection.style.opacity = chimesToggle.checked ? '1' : '0.4';\n  });\n\n  document.getElementById('clock-settings')?.addEventListener('click', () => {\n    loadSettings();\n    modal.classList.add('show');\n  });\n\n  document.getElementById('clock-chime-test')?.addEventListener('click', () => {\n    const vol = parseInt(volumeSlider.value, 10) / 100;\n    const bell = new Audio('/assets/sounds/church-bell.mp3');\n    bell.volume = vol;\n    bell.play().catch(() => {});\n  });\n\n  document.getElementById('clock-settings-save')?.addEventListener('click', () => {\n    const radio = modal.querySelector('input[name=\"clock-style-radio\"]:checked');\n    const style = radio ? radio.value : 'default';\n    safeSet('clock-style', style);\n    safeSet('clock-chimes', String(chimesToggle.checked));\n    safeSet('clock-chime-volume', volumeSlider.value);\n    currentStyle = style;\n    prevFlipDigits = '';\n    resetRenderLayout();\n    tick();\n    scheduleNextTick();\n    modal.classList.remove('show');\n    showNotification('Clock settings saved', 'success', 2000);\n  });\n\n  document.getElementById('clock-settings-cancel')?.addEventListener('click', () => {\n    modal.classList.remove('show');\n  });\n\n  wireModal(modal);\n\n  // Live preview when clicking style options\n  modal?.querySelectorAll('input[name=\"clock-style-radio\"]').forEach(radio => {\n    radio.addEventListener('change', () => {\n      currentStyle = radio.value;\n      prevFlipDigits = '';\n      resetRenderLayout();\n      tick();\n    });\n  });\n})();\n;\n// ========== CALENDAR WIDGET (DC-161) ==========\n// Zero-config for calendars deployed through DashCaddy (Radicale auto-wiring);\n// manual CalDAV/ICS sources via the \u2699\uFE0F settings modal. Weather-widget pattern:\n// compact top-bar display + weather-modal shell + server-backed settings.\n(function() {\n  const errorHandler = new ErrorHandler();\n\n  injectModal('calendar-modal', `<div id=\"calendar-modal\" class=\"weather-modal\">\n    <div class=\"weather-modal-content\" style=\"min-width:560px;max-width:720px;\">\n      <h3>\uD83D\uDCC5 Calendar</h3>\n      <div id=\"calendar-upcoming\" style=\"margin:0 0 14px;\">\n        <div style=\"font-size:0.8rem;color:var(--muted);margin-bottom:6px;\">Next 14 days</div>\n        <div id=\"calendar-upcoming-list\" style=\"display:flex;flex-direction:column;gap:4px;max-height:180px;overflow-y:auto;\">\n          <div style=\"color:var(--muted);font-size:0.85rem;\">No upcoming appointments.</div>\n        </div>\n      </div>\n      <div style=\"margin-top:14px;padding-top:12px;border-top:1px solid var(--border);\">\n        <label style=\"display:block;font-weight:600;color:var(--fg);margin-bottom:8px;\">Calendars</label>\n        <div id=\"calendar-sources-list\" style=\"display:flex;flex-direction:column;gap:6px;margin-bottom:10px;\"></div>\n        <details id=\"calendar-add-details\">\n          <summary style=\"cursor:pointer;font-size:0.85rem;color:var(--accent);\">+ Add a calendar (CalDAV URL or ICS feed)</summary>\n          <div style=\"margin-top:10px;display:flex;flex-direction:column;gap:8px;\">\n            <div style=\"display:flex;gap:8px;\">\n              <label style=\"font-size:0.82rem;\">Type\n                <select id=\"cal-add-type\" style=\"margin-left:6px;background:var(--bg);color:var(--fg);border:1px solid var(--border);border-radius:4px;padding:4px;\">\n                  <option value=\"caldav\">CalDAV</option>\n                  <option value=\"ics\">ICS feed (read-only)</option>\n                </select>\n              </label>\n              <label style=\"font-size:0.82rem;flex:1;\">Name\n                <input type=\"text\" id=\"cal-add-name\" placeholder=\"Work calendar\" maxlength=\"120\" style=\"width:100%;background:var(--bg);color:var(--fg);border:1px solid var(--border);border-radius:4px;padding:4px 8px;\">\n              </label>\n            </div>\n            <label style=\"font-size:0.82rem;\">URL\n              <input type=\"text\" id=\"cal-add-url\" placeholder=\"https://calendar.example.com/user/calendar/\" style=\"width:100%;background:var(--bg);color:var(--fg);border:1px solid var(--border);border-radius:4px;padding:4px 8px;\">\n            </label>\n            <div style=\"display:flex;gap:8px;\">\n              <label style=\"font-size:0.82rem;flex:1;\">User\n                <input type=\"text\" id=\"cal-add-user\" autocomplete=\"off\" style=\"width:100%;background:var(--bg);color:var(--fg);border:1px solid var(--border);border-radius:4px;padding:4px 8px;\">\n              </label>\n              <label style=\"font-size:0.82rem;flex:1;\">Password\n                <input type=\"password\" id=\"cal-add-pass\" autocomplete=\"new-password\" style=\"width:100%;background:var(--bg);color:var(--fg);border:1px solid var(--border);border-radius:4px;padding:4px 8px;\">\n              </label>\n            </div>\n            <div style=\"display:flex;gap:8px;justify-content:flex-end;\">\n              <button id=\"cal-add-test\">Test connection</button>\n              <button id=\"cal-add-save\">Save</button>\n            </div>\n            <div id=\"cal-add-status\" style=\"font-size:0.8rem;color:var(--muted);min-height:1em;\"></div>\n          </div>\n        </details>\n      </div>\n      <div class=\"weather-modal-buttons\"><button id=\"calendar-close\">Close</button></div>\n    </div></div>`);\n\n  const widgetEls = () => ({\n    icon: document.querySelector('.calendar-widget-icon'),\n    text: document.querySelector('.calendar-widget-text'),\n  });\n\n  function fmtWhen(start, allDay) {\n    const d = new Date(start);\n    const today = new Date(); today.setHours(0, 0, 0, 0);\n    const day = new Date(d); day.setHours(0, 0, 0, 0);\n    const days = Math.round((day - today) / 86400000);\n    const dayLabel = days === 0 ? 'Today' : days === 1 ? 'Tomorrow' :\n      d.toLocaleDateString(undefined, { weekday: 'short', month: 'short', day: 'numeric' });\n    const timeLabel = allDay ? 'all-day' : d.toLocaleTimeString(undefined, { hour: 'numeric', minute: '2-digit' });\n    return `${dayLabel} ${timeLabel}`;\n  }\n\n  async function fetchCalendar() {\n    const start = new Date(Date.now() - 86400000);\n    const end = new Date(Date.now() + 14 * 86400000);\n    const resp = await fetch(`/api/v1/calendar/events?start=${start.toISOString()}&end=${end.toISOString()}`, { cache: 'no-store' });\n    if (resp.status === 404) return { notConfigured: true };\n    if (!resp.ok) throw new Error(`Calendar API HTTP ${resp.status}`);\n    return resp.json();\n  }\n\n  function renderWidget(body) {\n    const els = widgetEls();\n    if (!els.icon || !els.text) return;\n    const events = (body && Array.isArray(body.events)) ? body.events : [];\n    if (!events.length) {\n      els.icon.textContent = '\uD83D\uDCC5';\n      els.text.textContent = 'No calendar';\n      return;\n    }\n    const next = events[0];\n    els.icon.textContent = next.allDay ? '\uD83D\uDDD3\uFE0F' : '\u23F0';\n    els.text.innerHTML = `${escapeHtml(next.title || 'Untitled')}\n      <span style=\"color:var(--muted);font-size:0.78em;\">\u00B7 ${escapeHtml(fmtWhen(next.start, next.allDay))}</span>`;\n  }\n\n  function renderUpcoming(body) {\n    const list = document.getElementById('calendar-upcoming-list');\n    if (!list) return;\n    const events = (body && Array.isArray(body.events)) ? body.events : [];\n    if (!events.length) {\n      list.innerHTML = '<div style=\"color:var(--muted);font-size:0.85rem;\">No upcoming appointments.</div>';\n      return;\n    }\n    list.innerHTML = events.slice(0, 12).map(ev =>\n      `<div style=\"display:flex;gap:8px;align-items:baseline;\">\n         <span style=\"font-size:0.78rem;color:var(--muted);white-space:nowrap;\">${escapeHtml(fmtWhen(ev.start, ev.allDay))}</span>\n         <span style=\"font-size:0.85rem;\">${escapeHtml(ev.title || 'Untitled')}</span>\n         ${ev.location ? `<span style=\"font-size:0.75rem;color:var(--muted);\">${escapeHtml(ev.location)}</span>` : ''}\n       </div>`).join('');\n  }\n\n  async function renderSources() {\n    const listEl = document.getElementById('calendar-sources-list');\n    if (!listEl) return;\n    let sources = [];\n    try {\n      const resp = await fetch('/api/v1/calendar/sources', { cache: 'no-store' });\n      if (resp.ok) {\n        const body = await resp.json();\n        sources = (body && Array.isArray(body.sources)) ? body.sources\n          : (Array.isArray(body) ? body : []);\n      }\n    } catch (e) { /* modal still usable */ }\n    if (!sources.length) {\n      listEl.innerHTML = '<div style=\"font-size:0.82rem;color:var(--muted);\">No calendars connected. Deploy Radicale from the App Selector to auto-connect one, or add a CalDAV/ICS URL below.</div>';\n      return;\n    }\n    listEl.innerHTML = sources.map(s => `\n      <div style=\"display:flex;gap:8px;align-items:center;border:1px solid var(--border);border-radius:6px;padding:6px 10px;\">\n        <span style=\"font-size:0.85rem;flex:1;\">${escapeHtml(s.name || s.id)}\n          <span style=\"color:var(--muted);font-size:0.72rem;\">\u00B7 ${escapeHtml(s.type)}${s.autoProvisioned ? ' \u00B7 auto-wired' : ''}</span></span>\n        <button class=\"cal-src-toggle\" data-id=\"${escapeHtml(s.id)}\" data-enabled=\"${s.enabled !== false ? '1' : '0'}\"\n          style=\"font-size:0.75rem;padding:2px 8px;\">${s.enabled !== false ? '\u2713 on' : 'off'}</button>\n        <button class=\"cal-src-del\" data-id=\"${escapeHtml(s.id)}\" style=\"font-size:0.75rem;padding:2px 8px;color:var(--err-fg);\">remove</button>\n      </div>`).join('');\n    listEl.querySelectorAll('.cal-src-toggle').forEach(btn => btn.addEventListener('click', async () => {\n      const id = btn.dataset.id;\n      const enable = btn.dataset.enabled !== '1';\n      await fetch(`/api/v1/calendar/sources/${encodeURIComponent(id)}`, {\n        method: 'PUT', headers: { 'Content-Type': 'application/json' },\n        body: JSON.stringify({ enabled: enable })\n      });\n      renderSources(); refresh();\n    }));\n    listEl.querySelectorAll('.cal-src-del').forEach(btn => btn.addEventListener('click', async () => {\n      const id = btn.dataset.id;\n      await fetch(`/api/v1/calendar/sources/${encodeURIComponent(id)}`, { method: 'DELETE' });\n      renderSources(); refresh();\n    }));\n  }\n\n  async function refresh() {\n    if (refresh._inFlight) return;\n    refresh._inFlight = true;\n    try {\n      const body = await fetchCalendar();\n      renderWidget(body);\n      if (document.getElementById('calendar-modal').style.display === 'flex') {\n        renderUpcoming(body);\n      }\n    } catch (e) {\n      errorHandler.log(e, 'calendar-widget');\n      const els = widgetEls();\n      if (els.text) els.text.textContent = 'Calendar offline';\n    } finally {\n      refresh._inFlight = false;\n    }\n  }\n\n  // ---- Settings modal wiring ----\n  function openModal() {\n    document.getElementById('calendar-modal').style.display = 'flex';\n    renderSources();\n    refresh();\n  }\n  function closeModal() {\n    document.getElementById('calendar-modal').style.display = 'none';\n  }\n\n  function formCreds() {\n    return {\n      type: document.getElementById('cal-add-type').value,\n      name: document.getElementById('cal-add-name').value.trim(),\n      url: document.getElementById('cal-add-url').value.trim(),\n      user: document.getElementById('cal-add-user').value.trim(),\n      pass: document.getElementById('cal-add-pass').value,\n    };\n  }\n\n  function setStatus(msg) {\n    document.getElementById('cal-add-status').textContent = msg;\n  }\n\n  document.getElementById('cal-add-test').addEventListener('click', async () => {\n    const f = formCreds();\n    if (!f.url) { setStatus('Enter a URL first.'); return; }\n    setStatus('Testing\u2026');\n    try {\n      const resp = await fetch('/api/v1/calendar/discover', {\n        method: 'POST', headers: { 'Content-Type': 'application/json' },\n        body: JSON.stringify({ url: f.url, user: f.user, pass: f.pass })\n      });\n      const body = await resp.json();\n      const p = body && body.probe;\n      if (p && p.ok) setStatus(`\u2713 Reachable (${p.server || 'server'})${p.looksLikeCalendar ? ' \u2014 looks like a calendar' : ''}`);\n      else setStatus(`\u2717 ${p && p.error ? p.error : 'Not reachable'}`);\n    } catch (e) {\n      setStatus(`\u2717 ${e.message}`);\n    }\n  });\n\n  document.getElementById('cal-add-save').addEventListener('click', async () => {\n    const f = formCreds();\n    if (!f.name || !f.url) { setStatus('Name and URL are required.'); return; }\n    try {\n      const resp = await fetch('/api/v1/calendar/sources', {\n        method: 'POST', headers: { 'Content-Type': 'application/json' },\n        body: JSON.stringify({ name: f.name, type: f.type, url: f.url, user: f.user, pass: f.pass })\n      });\n      if (!resp.ok) {\n        const body = await resp.json().catch(() => ({}));\n        setStatus(`\u2717 ${body.error || body.message || `HTTP ${resp.status}`}`);\n        return;\n      }\n      setStatus('Saved.');\n      document.getElementById('cal-add-details').open = false;\n      ['cal-add-name', 'cal-add-url', 'cal-add-user', 'cal-add-pass'].forEach(id => { document.getElementById(id).value = ''; });\n      renderSources(); refresh();\n    } catch (e) {\n      setStatus(`\u2717 ${e.message}`);\n    }\n  });\n\n  const calBtn = document.getElementById('calendar-widget');\n  if (calBtn) calBtn.addEventListener('click', openModal);\n  const calSettings = document.getElementById('calendar-settings');\n  if (calSettings) calSettings.addEventListener('click', (e) => { e.stopPropagation(); openModal(); });\n  const calClose = document.getElementById('calendar-close');\n  if (calClose) calClose.addEventListener('click', closeModal);\n\n  window.refreshCalendarWidget = refresh;\n\n  const POLL = (typeof DC !== 'undefined' && DC.POLL && DC.POLL.CALENDAR) || 300000;\n  setInterval(refresh, POLL);\n  setTimeout(refresh, 400);\n})();\n;\n// ========== CONNECT YOUR AI (DC-162) ==========\n// One button, one flow: click \"\uD83E\uDD16 Connect AI\" \u2192 pick Claude/ChatGPT/generic\n// \u2192 DashCaddy mints a dedicated dk_ key + ready-to-paste MCP config. The\n// dashboard's own session does the signing-in; the AI assistant authenticates\n// with the key against POST /api/v1/mcp. Keys listed/revokeable here too.\n(function() {\n  const errorHandler = new ErrorHandler();\n\n  injectModal('ai-connect-modal', `<div id=\"ai-connect-modal\" class=\"weather-modal\">\n    <div class=\"weather-modal-content\" style=\"min-width:560px;max-width:720px;\">\n      <h3>\uD83E\uDD16 Connect your AI assistant</h3>\n      <div id=\"aiconn-intro\" style=\"font-size:0.85rem;color:var(--muted);margin-bottom:12px;\">\n        DashCaddy speaks MCP \u2014 Claude, ChatGPT and other AI assistants can manage your\n        homelab (deploy apps, check health, edit DNS) through one endpoint.\n        Pick an assistant and DashCaddy generates the access key + config for it.\n      </div>\n\n      <div id=\"aiconn-endpoint\" style=\"display:none;margin:0 0 12px;padding:8px 10px;border:1px solid var(--border);border-radius:6px;font-size:0.8rem;\">\n        <span style=\"color:var(--muted);\">MCP endpoint:</span>\n        <code id=\"aiconn-endpoint-url\" style=\"user-select:all;\">\u2014</code>\n        <button id=\"aiconn-copy-endpoint\" style=\"margin-left:8px;font-size:0.75rem;\">Copy</button>\n        <div id=\"aiconn-tools\" style=\"color:var(--muted);margin-top:2px;\"></div>\n      </div>\n\n      <!-- Step 1: pick client -->\n      <div id=\"aiconn-step-pick\">\n        <div style=\"font-weight:600;margin:6px 0 8px;\">Choose your assistant:</div>\n        <div style=\"display:flex;gap:8px;flex-wrap:wrap;\">\n          <button class=\"aiconn-client-btn\" data-client=\"claude\">\uD83D\uDFE0 Claude</button>\n          <button class=\"aiconn-client-btn\" data-client=\"chatgpt\">\uD83D\uDFE2 ChatGPT</button>\n          <button class=\"aiconn-client-btn\" data-client=\"generic\">\uD83D\uDD0C Other / generic</button>\n        </div>\n      </div>\n\n      <!-- Step 2: the generated connection -->\n      <div id=\"aiconn-step-config\" style=\"display:none;margin-top:12px;\">\n        <div style=\"font-weight:600;margin-bottom:6px;\" id=\"aiconn-config-title\">Your access key (shown once):</div>\n        <div style=\"display:flex;gap:6px;align-items:center;margin-bottom:10px;\">\n          <code id=\"aiconn-key\" style=\"flex:1;padding:6px 8px;border:1px solid var(--accent);border-radius:4px;background:color-mix(in srgb, var(--accent) 8%, transparent);user-select:all;word-break:break-all;\">\u2014</code>\n          <button id=\"aiconn-copy-key\">Copy</button>\n        </div>\n        <div style=\"font-weight:600;margin-bottom:6px;\">Paste into your client:</div>\n        <pre id=\"aiconn-snippet\" style=\"white-space:pre-wrap;word-break:break-all;font-size:0.78rem;border:1px solid var(--border);border-radius:6px;padding:10px;max-height:220px;overflow:auto;margin:0 0 8px;\"></pre>\n        <div style=\"display:flex;gap:6px;align-items:center;margin-bottom:8px;\">\n          <button id=\"aiconn-copy-snippet\">Copy config</button>\n          <button id=\"aiconn-back\">\u2190 Choose a different assistant</button>\n        </div>\n        <div id=\"aiconn-client-note\" style=\"font-size:0.78rem;color:var(--muted);margin-bottom:10px;\"></div>\n      </div>\n\n      <!-- Existing connections -->\n      <div style=\"margin-top:14px;padding-top:12px;border-top:1px solid var(--border);\">\n        <div style=\"font-weight:600;margin-bottom:6px;\">Active AI connections</div>\n        <div id=\"aiconn-connections\" style=\"display:flex;flex-direction:column;gap:4px;max-height:160px;overflow-y:auto;\">\n          <div style=\"font-size:0.8rem;color:var(--muted);\">Loading\u2026</div>\n        </div>\n      </div>\n\n      <div class=\"weather-modal-buttons modal-footer-bar\">\n        <span id=\"aiconn-status\" style=\"flex:1;font-size:0.78rem;color:var(--muted);align-self:center;\"></span>\n        <button id=\"aiconn-close\">Close</button>\n      </div>\n    </div></div>`);\n\n  const $ = (id) => document.getElementById(id);\n  let info = null;\n\n  function setStatus(msg) { $('aiconn-status').textContent = msg; }\n\n  async function loadInfo() {\n    try {\n      const resp = await secureFetch('/api/v1/mcp/info');\n      if (!resp.ok) throw new Error(`HTTP ${resp.status}`);\n      const body = await resp.json();\n      info = body;\n      $('aiconn-endpoint').style.display = 'block';\n      $('aiconn-endpoint-url').textContent = body.endpoint;\n      $('aiconn-tools').textContent = `${body.toolCount} tools \u00B7 MCP ${body.protocolVersion} \u00B7 DashCaddy v${body.serverVersion}`;\n    } catch (e) {\n      errorHandler.log(e, 'ai-connect-info');\n      setStatus('MCP endpoint unavailable on this build.');\n    }\n  }\n\n  async function loadConnections() {\n    const listEl = $('aiconn-connections');\n    try {\n      const resp = await secureFetch('/api/v1/mcp/connections');\n      const body = await resp.json().catch(() => ({}));\n      const keys = (body && Array.isArray(body.connections)) ? body.connections : [];\n      if (!keys.length) {\n        listEl.innerHTML = '<div style=\"font-size:0.8rem;color:var(--muted);\">No connections yet \u2014 choose an assistant above.</div>';\n        return;\n      }\n      listEl.innerHTML = keys.map(k => `\n        <div style=\"display:flex;gap:8px;align-items:center;font-size:0.8rem;\">\n          <span style=\"flex:1;\">${escapeHtml(k.name)}\n            <span style=\"color:var(--muted);\">\u00B7 ${(k.scopes || []).join(',')} \u00B7 since ${escapeHtml((k.createdAt || '').slice(0, 10))}${k.lastUsed ? ' \u00B7 last used ' + escapeHtml(String(k.lastUsed).slice(0, 10)) : ''}</span></span>\n          <button class=\"aiconn-revoke\" data-id=\"${escapeHtml(k.id)}\" style=\"font-size:0.75rem;color:var(--err-fg);\">Revoke</button>\n        </div>`).join('');\n      listEl.querySelectorAll('.aiconn-revoke').forEach(btn => btn.addEventListener('click', async () => {\n        btn.disabled = true;\n        try {\n          const resp = await secureFetch(`/api/v1/auth/keys/${encodeURIComponent(btn.dataset.id)}`, { method: 'DELETE' });\n          if (resp.ok) { setStatus('Connection revoked.'); loadConnections(); }\n          else { const b = await resp.json().catch(() => ({})); setStatus(b.error || 'Revoke failed.'); btn.disabled = false; }\n        } catch (e) { setStatus('Revoke failed: ' + e.message); btn.disabled = false; }\n      }));\n    } catch (e) {\n      listEl.innerHTML = '<div style=\"font-size:0.8rem;color:var(--muted);\">Could not load connections.</div>';\n    }\n  }\n\n  async function createConnection(client) {\n    setStatus(`Creating ${client} connection\u2026`);\n    try {\n      const resp = await secureFetch('/api/v1/mcp/config', {\n        method: 'POST',\n        headers: { 'Content-Type': 'application/json' },\n        body: JSON.stringify({ client }),\n      });\n      const body = await resp.json().catch(() => ({}));\n      if (!resp.ok || !body.key) {\n        setStatus(body.error || `Failed (HTTP ${resp.status})`);\n        return;\n      }\n      $('aiconn-key').textContent = body.key;\n      // rev2 config shape: httpConfig = {url, transport, headers,\n      // mcpProtocolVersion} \u2014 the standard Streamable-HTTP connection card.\n      const snippet = body.httpConfig ? JSON.stringify(body.httpConfig, null, 2) : '';\n      $('aiconn-snippet').textContent = snippet || '(see note below)';\n      $('aiconn-client-note').textContent = body.note || '';\n      $('aiconn-config-title').textContent =\n        client === 'chatgpt' ? 'Access key (ChatGPT note below):' : 'Your access key (shown once):';\n      $('aiconn-step-pick').style.display = 'none';\n      $('aiconn-step-config').style.display = 'block';\n      setStatus('');\n      loadConnections();\n    } catch (e) {\n      errorHandler.log(e, 'ai-connect-create');\n      setStatus('Failed: ' + e.message);\n    }\n  }\n\n  function copyText(text, okMsg) {\n    if (navigator.clipboard && navigator.clipboard.writeText) {\n      navigator.clipboard.writeText(text).then(() => setStatus(okMsg)).catch(() => setStatus('Copy failed \u2014 select manually.'));\n    } else {\n      setStatus('Clipboard unavailable \u2014 select manually.');\n    }\n  }\n\n  // ---- wiring ----\n  $('ai-connect-btn').addEventListener('click', () => {\n    $('ai-connect-modal').style.display = 'flex';\n    $('aiconn-step-pick').style.display = 'block';\n    $('aiconn-step-config').style.display = 'none';\n    setStatus('');\n    loadInfo();\n    loadConnections();\n  });\n  $('aiconn-close').addEventListener('click', () => { $('ai-connect-modal').style.display = 'none'; });\n  $('aiconn-back').addEventListener('click', () => {\n    $('aiconn-step-config').style.display = 'none';\n    $('aiconn-step-pick').style.display = 'block';\n  });\n  document.querySelectorAll('.aiconn-client-btn').forEach(btn =>\n    btn.addEventListener('click', () => createConnection(btn.dataset.client)));\n  $('aiconn-copy-key').addEventListener('click', () => copyText($('aiconn-key').textContent, 'Key copied \u2014 paste it into your client.'));\n  $('aiconn-copy-snippet').addEventListener('click', () => copyText($('aiconn-snippet').textContent, 'Config copied.'));\n  $('aiconn-copy-endpoint').addEventListener('click', () => copyText(info ? info.endpoint : $('aiconn-endpoint-url').textContent, 'Endpoint copied.'));\n})();\n;\n// ========== CARD HEALTH & UPDATE BADGES ==========\n(function() {\n  // Fetch health data and update card UI\n  async function refreshCardHealth() {\n    try {\n      const res = await fetch('/api/v1/health-checks/status');\n      const data = await res.json();\n      if (!data.success || !data.status) return;\n\n      for (const [serviceId, svc] of Object.entries(data.status)) {\n        const uptimeEl = document.getElementById('uptime-' + serviceId);\n        const barEl = document.getElementById('uptime-bar-' + serviceId);\n        if (!uptimeEl) continue;\n\n        const uptime24 = svc.uptime?.['24h'];\n        if (uptime24 !== undefined && uptime24 !== null) {\n          const pct = uptime24.toFixed(1);\n          uptimeEl.textContent = `${pct}% uptime`;\n          // Color class\n          uptimeEl.className = 'uptime-chip';\n          if (uptime24 >= 99.9) uptimeEl.classList.add('excellent');\n          else if (uptime24 >= 99) uptimeEl.classList.add('good');\n          else if (uptime24 >= 95) uptimeEl.classList.add('degraded');\n          else uptimeEl.classList.add('poor');\n\n          if (barEl) barEl.style.width = pct + '%';\n        }\n      }\n    } catch (_) {\n      /* Health check API unavailable \u2014 uptime chips stay hidden */\n      console.warn('[Card Badges] Health check API unavailable');\n    }\n  }\n\n  // Track dismissed updates (per session)\n  let dismissedUpdates;\n  try {\n    dismissedUpdates = new Set(JSON.parse(safeSessionGet('dismissed-updates') || '[]'));\n  } catch (_) {\n    /* Session storage unavailable */\n    dismissedUpdates = new Set();\n  }\n\n  // Track global update state for cross-component access\n  let knownUpdates = [];\n\n  // Fetch update data and show badges\n  async function refreshCardUpdates(notifyNew) {\n    try {\n      const res = await fetch('/api/v1/updates/available');\n      const data = await res.json();\n      if (!data.success) return;\n\n      // Clear all update badges first\n      document.querySelectorAll('.update-available-badge').forEach(el => el.classList.remove('visible'));\n\n      const updates = data.updates || [];\n      knownUpdates = updates; // store globally\n\n      // Notify if new updates appeared (periodic check with notification)\n      if (notifyNew && updates.length > 0) {\n        const prev = window._lastKnownUpdateCount || 0;\n        if (prev > 0 && updates.length > prev) {\n          showNotification(`${updates.length} container update(s) available \u2014 click Update Management to review.`, 'info');\n        }\n        window._lastKnownUpdateCount = updates.length;\n      }\n\n      if (!updates.length) return;\n\n      for (const upd of updates) {\n        // Try to match by container name to service id\n        const apps = window.APPS || [];\n        for (const app of apps) {\n          if (app.containerId === upd.containerId || app.id === upd.containerName || app.name === upd.containerName) {\n            // Skip dismissed updates\n            if (dismissedUpdates.has(app.id)) break;\n            const badge = document.getElementById('update-badge-' + app.id);\n            const updateBtn = document.getElementById('update-btn-' + app.id);\n            if (badge) {\n              badge.classList.add('visible');\n              badge.title = `Update available \u2014 click to open Update Management.`;\n              badge.style.cursor = 'pointer';\n              badge.onclick = (e) => {\n                e.stopPropagation();\n                // Open Update Management modal focused on this app\n                if (window.openUpdateModal) window.openUpdateModal(app.id);\n              };\n            }\n            // Highlight update button if update is available\n            if (updateBtn) {\n              updateBtn.style.background = '#f97316';\n              updateBtn.style.borderColor = '#f97316';\n              updateBtn.style.boxShadow = '0 0 6px #f9731688';\n              updateBtn.title = `Update available \u2014 click to open Update Management.`;\n            }\n            break;\n          }\n        }\n      }\n    } catch (_) {\n      /* Updates API unavailable \u2014 badges stay hidden */\n      console.warn('[Card Badges] Updates API unavailable');\n    }\n  }\n\n  // Run health and update checks after main refresh, and periodically\n  function scheduleCardEnhancements() {\n    // Initial load (delayed to not compete with main probe checks)\n    setTimeout(() => {\n      refreshCardHealth();\n      refreshCardUpdates();\n    }, 5000);\n\n    // Periodic refresh every 60 seconds \u2014 notify on new updates detected\n    setInterval(() => {\n      refreshCardHealth();\n      refreshCardUpdates(true); // true = notify if new updates found\n    }, 60000);\n  }\n\n  // Hook into main refresh cycle\n  const origRefreshAll = window.refreshAll;\n  if (origRefreshAll) {\n    window.refreshAll = async function() {\n      try {\n        await origRefreshAll();\n        // Refresh health data after main status check\n        setTimeout(refreshCardHealth, 1000);\n      } catch (e) {\n        console.warn('[Card Badges] Error in refreshAll hook:', e.message);\n      }\n    };\n  }\n\n  scheduleCardEnhancements();\n})();\n;\n// ========== THEME PICKER + THEME BUILDER ==========\n(function () {\n  var themeBeforeBuilder = null;\n  var editingSlug = null;\n  var advancedOverrides = {}; // tracks which advanced fields user manually changed\n\n  // Display names for built-in themes\n  var THEME_LABELS = {\n    dark: 'Dark',\n    light: 'Light',\n    blue: 'Blue',\n    black: 'Black',\n    nord: 'Nord',\n    dracula: 'Dracula',\n    'solarized-dark': 'Solarized Dark',\n    'solarized-light': 'Solarized Light',\n    taxi: 'Taxi',\n    ocean: 'Ocean',\n  };\n\n  // Color picker field definitions: [css-prop, label, section]\n  var FIELDS = [\n    ['bg',            'Background',    'base'],\n    ['card-base',     'Card',          'base'],\n    ['fg',            'Text',          'base'],\n    ['muted',         'Muted Text',    'base'],\n    ['border',        'Border',        'base'],\n    ['accent',        'Accent',        'accent'],\n    ['accent-strong', 'Accent Strong', 'accent'],\n    ['ok-bg',         'OK Background', 'status'],\n    ['ok-fg',         'OK Text',       'status'],\n    ['bad-bg',        'Error Bg',      'status'],\n    ['bad-fg',        'Error Text',    'status'],\n    ['dot-ok',        'Dot OK',        'status'],\n    ['dot-bad',       'Dot Error',     'status'],\n    ['uptime',        'Uptime Bar',    'status'],\n    ['hover',         'Hover',         'advanced'],\n    ['card-hover',    'Card Hover',    'advanced'],\n    ['base',          'Tags/Badges',   'advanced'],\n    ['fg-muted',      'Dim Text',      'advanced'],\n    ['success',       'Success',       'advanced'],\n    ['error',         'Error',         'advanced'],\n    ['warning',       'Warning',       'advanced'],\n  ];\n\n  // \u2500\u2500\u2500 Theme Cycle Button \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\n  var themeBtn = document.getElementById('theme');\n  if (!themeBtn) return;\n  var themeLabel = document.getElementById('theme-label');\n\n  function getLabelFor(t) {\n    if (THEME_LABELS[t]) return THEME_LABELS[t];\n    var userThemes = safeGetJSON(window.USER_THEMES_KEY, {});\n    if (userThemes[t]) return userThemes[t].name || t;\n    return t;\n  }\n\n  function updateLabel() {\n    if (themeLabel) themeLabel.textContent = getLabelFor(window.getActiveTheme());\n  }\n\n  themeBtn.addEventListener('click', function () {\n    var list = window.THEMES.slice();\n    var current = window.getActiveTheme();\n    var idx = list.indexOf(current);\n    var next = list[(idx + 1) % list.length];\n    window.applyTheme(next);\n    updateLabel();\n  });\n\n  updateLabel();\n\n  // \u2500\u2500\u2500 Theme Builder Modal \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\n  function buildFieldsHTML() {\n    var sections = { base: 'Base Colors', accent: 'Accent', status: 'Status', advanced: 'Advanced (auto-derived)' };\n    var grouped = {};\n    FIELDS.forEach(function (f) {\n      if (!grouped[f[2]]) grouped[f[2]] = [];\n      grouped[f[2]].push(f);\n    });\n\n    var html = '';\n    Object.keys(sections).forEach(function (key) {\n      if (key === 'advanced') {\n        html += '<div id=\"theme-builder-advanced-toggle\" class=\"theme-builder-advanced-toggle\" style=\"margin:12px 0 4px;cursor:pointer;color:var(--accent);font-size:.85rem;user-select:none;\">Show advanced colors &#9660;</div>';\n        html += '<div id=\"theme-builder-advanced\" class=\"theme-builder-section\" style=\"display:none;\">';\n      } else {\n        html += '<div class=\"theme-builder-section\">';\n      }\n      html += '<div class=\"theme-builder-section-title\">' + sections[key] + '</div>';\n      (grouped[key] || []).forEach(function (f) {\n        html += '<div class=\"theme-builder-row\">' +\n          '<span class=\"theme-builder-label\">' + f[1] + '</span>' +\n          '<input type=\"color\" class=\"theme-builder-color\" data-prop=\"' + f[0] + '\"' + (key === 'advanced' ? ' data-advanced=\"1\"' : '') + ' value=\"#000000\" />' +\n          '<span class=\"theme-builder-hex\" data-hex=\"' + f[0] + '\">#000000</span>' +\n          '</div>';\n      });\n      html += '</div>';\n    });\n    return html;\n  }\n\n  function buildStartFromOptions() {\n    return window.THEMES.map(function (t) {\n      return '<option value=\"' + t + '\">' + getLabelFor(t) + '</option>';\n    }).join('');\n  }\n\n  var modalHTML = '<div id=\"theme-builder-modal\" class=\"weather-modal\">' +\n    '<div class=\"weather-modal-content\" style=\"min-width:420px;max-width:560px;\">' +\n    '<h3>Theme Builder</h3>' +\n\n    // Edit existing user themes dropdown\n    '<div id=\"theme-builder-existing\" style=\"margin-bottom:16px;display:none;\">' +\n    '<label style=\"font-size:.85rem;color:var(--muted);margin-right:8px;\">Edit:</label>' +\n    '<select id=\"theme-builder-edit-select\" style=\"padding:6px 10px;background:var(--card-bg);color:var(--fg);border:1px solid var(--border);border-radius:6px;font-size:.85rem;margin-right:8px;\">' +\n    '<option value=\"\">\u2014 New Theme \u2014</option>' +\n    '</select>' +\n    '<button id=\"theme-builder-delete\" style=\"padding:4px 10px;background:color-mix(in srgb,var(--bad-fg) 15%,transparent);border:1px solid var(--bad-fg);color:var(--bad-fg);border-radius:6px;font-size:.8rem;cursor:pointer;\">Delete</button>' +\n    '</div>' +\n\n    '<div style=\"margin-bottom:16px;\">' +\n    '<label style=\"font-size:.85rem;color:var(--muted);margin-right:8px;\">Name:</label>' +\n    '<input type=\"text\" id=\"theme-builder-name\" maxlength=\"20\" placeholder=\"My Theme\" ' +\n    'style=\"padding:6px 10px;background:var(--card-bg);color:var(--fg);border:1px solid var(--border);border-radius:6px;font-size:.85rem;width:140px;\" />' +\n    '</div>' +\n\n    '<div style=\"margin-bottom:16px;display:flex;align-items:center;\">' +\n    '<label style=\"font-size:.85rem;color:var(--muted);margin-right:8px;cursor:pointer;\" for=\"theme-builder-lightbg\">' +\n    '<input type=\"checkbox\" id=\"theme-builder-lightbg\" style=\"margin-right:6px;cursor:pointer;vertical-align:middle;\" />' +\n    'Light background (use dark logo)</label>' +\n    '</div>' +\n\n    '<div style=\"margin-bottom:16px;\">' +\n    '<label style=\"font-size:.85rem;color:var(--muted);margin-right:8px;\">Start from:</label>' +\n    '<select id=\"theme-builder-start\" style=\"padding:6px 10px;background:var(--card-bg);color:var(--fg);border:1px solid var(--border);border-radius:6px;font-size:.85rem;\">' +\n    buildStartFromOptions() +\n    '</select>' +\n    '</div>' +\n\n    '<div class=\"theme-builder-preview\" id=\"theme-builder-preview\">' +\n    '<div class=\"theme-builder-card\" id=\"theme-preview-card\">' +\n    '<div class=\"preview-title\">Sample Card</div>' +\n    '<div class=\"preview-muted\">Secondary text preview</div>' +\n    '<div class=\"preview-badges\">' +\n    '<span class=\"preview-badge\" id=\"preview-badge-ok\">ON</span>' +\n    '<span class=\"preview-badge\" id=\"preview-badge-bad\">OFF</span>' +\n    '</div>' +\n    '<div class=\"preview-dots\">' +\n    '<span><span class=\"preview-dot\" id=\"preview-dot-ok\"></span> Online</span>' +\n    '<span><span class=\"preview-dot\" id=\"preview-dot-bad\"></span> Offline</span>' +\n    '</div>' +\n    '<button class=\"preview-btn\" id=\"preview-accent-btn\">Accent Button</button>' +\n    '</div>' +\n    '</div>' +\n\n    buildFieldsHTML() +\n\n    '<div class=\"weather-modal-buttons\">' +\n    '<button id=\"theme-builder-cancel\">Cancel</button>' +\n    '<button id=\"theme-builder-import\" style=\"margin-left:auto;\" title=\"Import theme from JSON file\">Import</button>' +\n    '<button id=\"theme-builder-export\" title=\"Export theme as JSON file\">Export</button>' +\n    '<button id=\"theme-builder-save\" class=\"btn-accent\">Save Theme</button>' +\n    '</div>' +\n    '</div></div>';\n\n  injectModal('theme-builder-modal', modalHTML);\n\n  var modal = document.getElementById('theme-builder-modal');\n  var startSelect = document.getElementById('theme-builder-start');\n  var nameInput = document.getElementById('theme-builder-name');\n  var editSelect = document.getElementById('theme-builder-edit-select');\n  var existingSection = document.getElementById('theme-builder-existing');\n  var lightBgCheck = document.getElementById('theme-builder-lightbg');\n  var pickers = modal.querySelectorAll('.theme-builder-color');\n  var advancedSection = document.getElementById('theme-builder-advanced');\n  var advancedToggle = document.getElementById('theme-builder-advanced-toggle');\n  var exportBtn = document.getElementById('theme-builder-export');\n\n  // \u2500\u2500\u2500 Advanced toggle \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\n  var advancedVisible = false;\n  advancedToggle.addEventListener('click', function () {\n    advancedVisible = !advancedVisible;\n    advancedSection.style.display = advancedVisible ? '' : 'none';\n    advancedToggle.innerHTML = advancedVisible\n      ? 'Hide advanced colors &#9650;'\n      : 'Show advanced colors &#9660;';\n  });\n\n  // \u2500\u2500\u2500 Color picker helpers \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\n  function getCurrentColors() {\n    var colors = {};\n    pickers.forEach(function (p) {\n      colors[p.dataset.prop] = p.value;\n    });\n    colors['card-bg'] = colors['card-base'];\n    return colors;\n  }\n\n  function getBaseColors() {\n    var colors = {};\n    pickers.forEach(function (p) {\n      if (!p.dataset.advanced) colors[p.dataset.prop] = p.value;\n    });\n    colors['card-bg'] = colors['card-base'];\n    if (lightBgCheck.checked) colors.lightBg = true;\n    return colors;\n  }\n\n  function updateAdvancedFromDerived() {\n    var base = getBaseColors();\n    var derived = window.deriveExtendedColors ? window.deriveExtendedColors(base) : {};\n    pickers.forEach(function (p) {\n      if (p.dataset.advanced && !advancedOverrides[p.dataset.prop]) {\n        var val = derived[p.dataset.prop] || '#333333';\n        p.value = val;\n        var hex = modal.querySelector('[data-hex=\"' + p.dataset.prop + '\"]');\n        if (hex) hex.textContent = val.toUpperCase();\n      }\n    });\n  }\n\n  function loadThemeIntoPickers(themeName) {\n    var colors = window.THEME_COLORS[themeName];\n    if (!colors) return;\n    advancedOverrides = {};\n    pickers.forEach(function (p) {\n      var val = colors[p.dataset.prop] || '#000000';\n      if (val.startsWith('rgba') || val.startsWith('color-mix')) val = '#333333';\n      p.value = val;\n      var hex = modal.querySelector('[data-hex=\"' + p.dataset.prop + '\"]');\n      if (hex) hex.textContent = val.toUpperCase();\n    });\n    lightBgCheck.checked = !!colors.lightBg;\n    updatePreview();\n  }\n\n  function loadUserThemeIntoPickers(slug) {\n    var userThemes = safeGetJSON(window.USER_THEMES_KEY, {});\n    var theme = userThemes[slug];\n    if (!theme) return;\n    advancedOverrides = {};\n    pickers.forEach(function (p) {\n      var val = theme[p.dataset.prop] || '#000000';\n      p.value = val;\n      var hex = modal.querySelector('[data-hex=\"' + p.dataset.prop + '\"]');\n      if (hex) hex.textContent = val.toUpperCase();\n      // If theme has explicit advanced values, mark as overridden\n      if (p.dataset.advanced && theme[p.dataset.prop]) {\n        advancedOverrides[p.dataset.prop] = true;\n      }\n    });\n    nameInput.value = theme.name || '';\n    lightBgCheck.checked = !!theme.lightBg;\n    // Fill any missing advanced fields from derivation\n    updateAdvancedFromDerived();\n    updatePreview();\n  }\n\n  function updatePreview() {\n    var c = getCurrentColors();\n    var preview = document.getElementById('theme-builder-preview');\n    var card = document.getElementById('theme-preview-card');\n    var title = card.querySelector('.preview-title');\n    var muted = card.querySelector('.preview-muted');\n    var badgeOk = document.getElementById('preview-badge-ok');\n    var badgeBad = document.getElementById('preview-badge-bad');\n    var dotOk = document.getElementById('preview-dot-ok');\n    var dotBad = document.getElementById('preview-dot-bad');\n    var btn = document.getElementById('preview-accent-btn');\n    var dots = card.querySelector('.preview-dots');\n\n    preview.style.background = c['bg'];\n    card.style.background = c['card-base'];\n    card.style.borderColor = c['border'];\n    title.style.color = c['fg'];\n    muted.style.color = c['muted'];\n    badgeOk.style.background = c['ok-bg'];\n    badgeOk.style.color = c['ok-fg'];\n    badgeBad.style.background = c['bad-bg'];\n    badgeBad.style.color = c['bad-fg'];\n    dotOk.style.background = c['dot-ok'];\n    dotBad.style.background = c['dot-bad'];\n    dots.style.color = c['fg'];\n    btn.style.background = c['accent'];\n    btn.style.color = c['bg'];\n  }\n\n  function applyColorsLive(colors) {\n    // Include derived colors for full live preview\n    var derived = window.deriveExtendedColors ? window.deriveExtendedColors(colors) : {};\n    window.THEME_PROPS.forEach(function (prop) {\n      var val = colors[prop] || derived[prop];\n      if (val) {\n        document.documentElement.style.setProperty('--' + prop, val);\n      }\n    });\n  }\n\n  // Wire up color pickers\n  pickers.forEach(function (p) {\n    p.addEventListener('input', function () {\n      var hex = modal.querySelector('[data-hex=\"' + p.dataset.prop + '\"]');\n      if (hex) hex.textContent = p.value.toUpperCase();\n\n      // Track manual advanced overrides\n      if (p.dataset.advanced) {\n        advancedOverrides[p.dataset.prop] = true;\n      } else {\n        // Base color changed \u2014 re-derive advanced values (unless overridden)\n        updateAdvancedFromDerived();\n      }\n\n      updatePreview();\n      applyColorsLive(getCurrentColors());\n    });\n  });\n\n  // Light-bg checkbox should re-derive advanced colors\n  lightBgCheck.addEventListener('change', function () {\n    updateAdvancedFromDerived();\n    updatePreview();\n    applyColorsLive(getCurrentColors());\n  });\n\n  startSelect.addEventListener('change', function () {\n    advancedOverrides = {};\n    loadThemeIntoPickers(startSelect.value);\n    applyColorsLive(getCurrentColors());\n  });\n\n  // Populate and refresh the edit-existing dropdown\n  function refreshEditDropdown() {\n    var userThemes = safeGetJSON(window.USER_THEMES_KEY, {});\n    var slugs = Object.keys(userThemes);\n    editSelect.innerHTML = '<option value=\"\">\u2014 New Theme \u2014</option>';\n    slugs.forEach(function (slug) {\n      var opt = document.createElement('option');\n      opt.value = slug;\n      opt.textContent = userThemes[slug].name || slug;\n      editSelect.appendChild(opt);\n    });\n    existingSection.style.display = slugs.length ? '' : 'none';\n  }\n\n  // Also refresh \"Start from\" options\n  function refreshStartFrom() {\n    startSelect.innerHTML = buildStartFromOptions();\n  }\n\n  // Edit dropdown change\n  editSelect.addEventListener('change', function () {\n    var slug = this.value;\n    if (slug) {\n      editingSlug = slug;\n      loadUserThemeIntoPickers(slug);\n      applyColorsLive(getCurrentColors());\n    } else {\n      editingSlug = null;\n      advancedOverrides = {};\n      nameInput.value = '';\n      startSelect.value = window.getActiveTheme();\n      loadThemeIntoPickers(startSelect.value);\n    }\n    exportBtn.style.display = editingSlug ? '' : 'none';\n  });\n\n  function openBuilder() {\n    themeBeforeBuilder = window.getActiveTheme();\n    editingSlug = null;\n    advancedOverrides = {};\n\n    // Reset advanced section to collapsed\n    advancedVisible = false;\n    advancedSection.style.display = 'none';\n    advancedToggle.innerHTML = 'Show advanced colors &#9660;';\n\n    refreshEditDropdown();\n    refreshStartFrom();\n\n    var userThemes = safeGetJSON(window.USER_THEMES_KEY, {});\n    if (userThemes[themeBeforeBuilder]) {\n      // Active theme is a user theme \u2014 open it for editing\n      editSelect.value = themeBeforeBuilder;\n      editingSlug = themeBeforeBuilder;\n      loadUserThemeIntoPickers(themeBeforeBuilder);\n    } else {\n      editSelect.value = '';\n      nameInput.value = '';\n      startSelect.value = themeBeforeBuilder;\n      loadThemeIntoPickers(themeBeforeBuilder);\n    }\n\n    exportBtn.style.display = editingSlug ? '' : 'none';\n    modal.classList.add('show');\n  }\n\n  var customizeBtn = document.getElementById('theme-customize-btn');\n  if (customizeBtn) {\n    customizeBtn.addEventListener('click', function () { openBuilder(); });\n  }\n\n  // \u2500\u2500\u2500 Save \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\n  document.getElementById('theme-builder-save').addEventListener('click', function () {\n    var colors = getCurrentColors();\n    var name = nameInput.value.trim();\n    if (!name) {\n      showNotification('Please enter a theme name', 'warning', 3000);\n      nameInput.focus();\n      return;\n    }\n\n    var userThemes = safeGetJSON(window.USER_THEMES_KEY, {});\n    var slug;\n    var oldSlug = null;\n\n    if (editingSlug) {\n      slug = editingSlug;\n      // If name changed, re-slugify and potentially rename\n      var newSlug = window.slugifyThemeName(name, editingSlug);\n      if (newSlug !== editingSlug) {\n        oldSlug = editingSlug;\n        delete userThemes[editingSlug];\n        var idx = window.THEMES.indexOf(editingSlug);\n        if (idx !== -1) window.THEMES.splice(idx, 1);\n        delete window.THEME_COLORS[editingSlug];\n        slug = newSlug;\n      }\n    } else {\n      slug = window.slugifyThemeName(name);\n    }\n\n    // Build theme data with ALL color properties\n    var themeData = { name: name };\n    if (lightBgCheck.checked) themeData.lightBg = true;\n    window.THEME_PROPS.forEach(function (p) {\n      if (colors[p]) themeData[p] = colors[p];\n    });\n\n    // Update localStorage cache immediately for instant UI\n    userThemes[slug] = themeData;\n    safeSet(window.USER_THEMES_KEY, JSON.stringify(userThemes));\n\n    // Clear inline preview properties\n    window.clearCustomProperties();\n\n    // Re-inject CSS and apply\n    window.injectUserThemeStyles();\n    window.applyTheme(slug);\n    modal.classList.remove('show');\n    updateLabel();\n\n    // Save to server (source of truth)\n    var apiColors = {};\n    window.THEME_PROPS.forEach(function (p) { if (colors[p]) apiColors[p] = colors[p]; });\n\n    // If slug changed, delete the old one from server\n    if (oldSlug) {\n      secureFetch('/api/v1/themes/' + oldSlug, { method: 'DELETE' }).catch(function () {});\n    }\n\n    secureFetch('/api/v1/themes/' + slug, {\n      method: 'POST',\n      headers: { 'Content-Type': 'application/json' },\n      body: JSON.stringify({ name: name, colors: apiColors, lightBg: lightBgCheck.checked })\n    }).then(function () {\n      showNotification(name + ' theme saved', 'success', 3000);\n    }).catch(function () {\n      showNotification(name + ' theme saved locally (server sync failed)', 'warning', 3000);\n    });\n  });\n\n  // \u2500\u2500\u2500 Cancel \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\n  document.getElementById('theme-builder-cancel').addEventListener('click', function () {\n    modal.classList.remove('show');\n    window.clearCustomProperties();\n    if (themeBeforeBuilder) {\n      window.applyTheme(themeBeforeBuilder);\n    }\n  });\n\n  // \u2500\u2500\u2500 Delete \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\n  document.getElementById('theme-builder-delete').addEventListener('click', function () {\n    if (!editingSlug) return;\n\n    var userThemes = safeGetJSON(window.USER_THEMES_KEY, {});\n    var name = userThemes[editingSlug] ? userThemes[editingSlug].name : editingSlug;\n\n    if (!confirm('Delete \"' + name + '\" theme?')) return;\n\n    var slugToDelete = editingSlug;\n\n    // Update localStorage cache immediately\n    delete userThemes[slugToDelete];\n    safeSet(window.USER_THEMES_KEY, JSON.stringify(userThemes));\n\n    // Remove from runtime\n    var idx = window.THEMES.indexOf(slugToDelete);\n    if (idx !== -1) window.THEMES.splice(idx, 1);\n    delete window.THEME_COLORS[slugToDelete];\n\n    window.clearCustomProperties();\n    window.injectUserThemeStyles();\n\n    var fallback = themeBeforeBuilder && themeBeforeBuilder !== slugToDelete ? themeBeforeBuilder : 'dark';\n    window.applyTheme(fallback);\n\n    editingSlug = null;\n    modal.classList.remove('show');\n    updateLabel();\n\n    // Delete from server\n    secureFetch('/api/v1/themes/' + slugToDelete, { method: 'DELETE' }).then(function () {\n      showNotification(name + ' theme deleted', 'success', 3000);\n    }).catch(function () {\n      showNotification(name + ' theme deleted locally (server sync failed)', 'warning', 3000);\n    });\n  });\n\n  // \u2500\u2500\u2500 Export \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\n  document.getElementById('theme-builder-export').addEventListener('click', function () {\n    if (!editingSlug) {\n      showNotification('Save the theme first, then export', 'warning', 3000);\n      return;\n    }\n    var userThemes = safeGetJSON(window.USER_THEMES_KEY, {});\n    var theme = userThemes[editingSlug];\n    if (!theme) return;\n\n    var exportData = {\n      _dashcaddy_theme: true,\n      version: '1.0',\n      exportDate: new Date().toISOString(),\n      slug: editingSlug,\n      name: theme.name,\n      lightBg: theme.lightBg || false,\n      colors: {}\n    };\n    window.THEME_PROPS.forEach(function (p) {\n      if (theme[p]) exportData.colors[p] = theme[p];\n    });\n\n    var blob = new Blob([JSON.stringify(exportData, null, 2)], { type: 'application/json' });\n    var url = URL.createObjectURL(blob);\n    var a = document.createElement('a');\n    a.href = url;\n    a.download = editingSlug + '-theme.json';\n    document.body.appendChild(a);\n    a.click();\n    document.body.removeChild(a);\n    URL.revokeObjectURL(url);\n    showNotification('Theme exported as ' + editingSlug + '-theme.json', 'success', 3000);\n  });\n\n  // \u2500\u2500\u2500 Import \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\n  document.getElementById('theme-builder-import').addEventListener('click', function () {\n    var input = document.createElement('input');\n    input.type = 'file';\n    input.accept = '.json';\n    input.onchange = function (e) {\n      var file = e.target.files[0];\n      if (!file) return;\n      var reader = new FileReader();\n      reader.onload = function (ev) {\n        try {\n          var data = JSON.parse(ev.target.result);\n\n          // Support both wrapped format and raw theme format\n          var themeName, themeColors, themeLightBg;\n          if (data._dashcaddy_theme && data.colors) {\n            // Wrapped export format\n            themeName = data.name || 'Imported';\n            themeColors = data.colors;\n            themeLightBg = data.lightBg || false;\n          } else if (data.name && (data.bg || data['card-base'])) {\n            // Raw theme JSON (same format as server files)\n            themeName = data.name;\n            themeColors = {};\n            window.THEME_PROPS.forEach(function (p) { if (data[p]) themeColors[p] = data[p]; });\n            themeLightBg = data.lightBg || false;\n          } else {\n            throw new Error('Not a valid DashCaddy theme file');\n          }\n\n          // Load into builder\n          nameInput.value = themeName;\n          lightBgCheck.checked = !!themeLightBg;\n          editingSlug = null;\n          editSelect.value = '';\n          advancedOverrides = {};\n\n          // Apply colors to pickers\n          pickers.forEach(function (p) {\n            var val = themeColors[p.dataset.prop] || '#000000';\n            p.value = val;\n            var hex = modal.querySelector('[data-hex=\"' + p.dataset.prop + '\"]');\n            if (hex) hex.textContent = val.toUpperCase();\n            if (p.dataset.advanced && themeColors[p.dataset.prop]) {\n              advancedOverrides[p.dataset.prop] = true;\n            }\n          });\n\n          // Fill any missing advanced fields\n          updateAdvancedFromDerived();\n          updatePreview();\n          applyColorsLive(getCurrentColors());\n          exportBtn.style.display = 'none';\n          showNotification('\"' + themeName + '\" loaded into builder. Click Save to keep it.', 'success', 5000);\n        } catch (err) {\n          showNotification('Import failed: ' + err.message, 'error', 5000);\n        }\n      };\n      reader.readAsText(file);\n    };\n    input.click();\n  });\n\n  // \u2500\u2500\u2500 Modal close handling \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\n  wireModal(modal);\n\n  modal.addEventListener('click', function (e) {\n    if (e.target === modal) {\n      window.clearCustomProperties();\n      if (themeBeforeBuilder) window.applyTheme(themeBeforeBuilder);\n    }\n  });\n})();\n;\n// License Management UI\n(function() {\n  // Inject license modal HTML\n  injectModal('license-modal', `<div id=\"license-modal\" class=\"weather-modal\">\n    <div class=\"weather-modal-content\" style=\"min-width: 420px; max-width: 520px;\">\n      <h3>DashCaddy License</h3>\n      <p style=\"font-size: 0.85rem; color: var(--muted); margin: 0 0 16px;\">\n        Activate a license code to unlock premium features.\n      </p>\n\n      <div id=\"license-status-section\" style=\"margin-bottom: 16px;\">\n        <div id=\"license-badge\" style=\"display: inline-flex; align-items: center; gap: 6px; padding: 6px 14px; border-radius: 20px; font-size: 0.85rem; font-weight: 600; margin-bottom: 12px;\">\n          <span id=\"license-badge-icon\"></span>\n          <span id=\"license-badge-text\"></span>\n        </div>\n        <div id=\"license-details\" style=\"font-size: 0.85rem; color: var(--muted); line-height: 1.6;\"></div>\n      </div>\n\n      <div id=\"license-activate-section\">\n        <label class=\"form-label-bold\">License Code:</label>\n        <input type=\"text\" id=\"license-code-input\" placeholder=\"DC-XXXXX-XXXXX-XXXXX-XXXXX-XXXXX\"\n          maxlength=\"35\" spellcheck=\"false\" autocomplete=\"off\"\n          style=\"width: 100%; padding: 10px 12px; border: 1px solid var(--border); border-radius: 4px; background: var(--card-bg); color: var(--fg); font-size: 1rem; font-family: monospace; letter-spacing: 1px;\" />\n        <p class=\"tiny-hint\">Enter your license code to activate premium features</p>\n      </div>\n\n      <div id=\"license-features\" style=\"margin-top: 16px;\">\n        <label class=\"form-label-bold\" style=\"margin-bottom: 8px; display: block;\">Premium Features:</label>\n        <div id=\"license-feature-list\" style=\"display: grid; gap: 8px;\"></div>\n      </div>\n\n      <div id=\"license-error\" style=\"display: none; margin-top: 12px; padding: 10px; border-radius: 4px; background: rgba(231,76,60,0.15); color: var(--bad-fg); font-size: 0.85rem;\"></div>\n      <div id=\"license-success\" style=\"display: none; margin-top: 12px; padding: 10px; border-radius: 4px; background: rgba(46,204,113,0.15); color: var(--ok-fg); font-size: 0.85rem;\"></div>\n\n      <div class=\"weather-modal-buttons\" style=\"margin-top: 16px;\">\n        <button id=\"license-cancel\">Close</button>\n        <button id=\"license-deactivate\" class=\"btn-accent\" style=\"display: none; background: var(--bad-bg); border-color: var(--bad-fg); color: var(--bad-fg);\">Deactivate</button>\n        <button id=\"license-activate\" class=\"btn-accent\">Activate</button>\n      </div>\n    </div>\n  </div>`);\n\n  const modal = document.getElementById('license-modal');\n  const codeInput = document.getElementById('license-code-input');\n  const activateBtn = document.getElementById('license-activate');\n  const deactivateBtn = document.getElementById('license-deactivate');\n  const errorEl = document.getElementById('license-error');\n  const successEl = document.getElementById('license-success');\n  const badgeIcon = document.getElementById('license-badge-icon');\n  const badgeText = document.getElementById('license-badge-text');\n  const badge = document.getElementById('license-badge');\n  const detailsEl = document.getElementById('license-details');\n  const featureList = document.getElementById('license-feature-list');\n  const activateSection = document.getElementById('license-activate-section');\n\n  let currentStatus = null;\n\n  function hideMessages() {\n    errorEl.style.display = 'none';\n    successEl.style.display = 'none';\n  }\n\n  function showError(msg) {\n    hideMessages();\n    errorEl.textContent = msg;\n    errorEl.style.display = 'block';\n  }\n\n  function showSuccess(msg) {\n    hideMessages();\n    successEl.textContent = msg;\n    successEl.style.display = 'block';\n  }\n\n  function renderStatus(status) {\n    currentStatus = status;\n\n    if (status.active) {\n      badge.style.background = 'rgba(46,204,113,0.15)';\n      badge.style.color = 'var(--ok-fg)';\n      badgeIcon.textContent = '\\u2605';\n      badgeText.textContent = 'Premium Active';\n      const expiryLine = status.lifetime\n        ? '<div>License: <strong>LIFETIME</strong></div>'\n        : `<div>Expires: <strong>${new Date(status.expiresAt).toLocaleDateString()}</strong> (${status.daysRemaining} days remaining)</div>`;\n      detailsEl.innerHTML = `\n        <div>Code: <code style=\"font-family: monospace;\">${status.code || '***'}</code></div>\n        ${expiryLine}\n      `;\n      activateSection.style.display = 'none';\n      activateBtn.style.display = 'none';\n      deactivateBtn.style.display = '';\n    } else {\n      badge.style.background = 'rgba(149,165,166,0.15)';\n      badge.style.color = 'var(--muted)';\n      badgeIcon.textContent = '\\u2606';\n      badgeText.textContent = status.expired ? 'License Expired' : 'Free Tier';\n      detailsEl.innerHTML = status.expired\n        ? '<div>Your license has expired. Enter a new code to renew.</div>'\n        : '<div>Enter a license code to unlock premium features.</div>';\n      activateSection.style.display = '';\n      activateBtn.style.display = '';\n      deactivateBtn.style.display = 'none';\n    }\n\n    // Render feature list\n    const features = status.premiumFeatures || {};\n    const activeFeatures = new Set(status.features || []);\n    featureList.innerHTML = Object.entries(features).map(([key, info]) => {\n      const active = activeFeatures.has(key);\n      return `<div style=\"display: flex; align-items: center; gap: 8px; padding: 8px 12px; border-radius: 6px; background: var(--card-bg); border: 1px solid var(--border);\">\n        <span style=\"font-size: 1.1rem;\">${active ? '\\u2705' : '\\uD83D\\uDD12'}</span>\n        <div>\n          <div style=\"font-weight: 600; font-size: 0.9rem;\">${info.name}</div>\n          <div style=\"font-size: 0.78rem; color: var(--muted);\">${info.description}</div>\n        </div>\n      </div>`;\n    }).join('');\n  }\n\n  async function loadStatus() {\n    try {\n      const resp = await fetch('/api/v1/license/status');\n      const data = await resp.json();\n      if (data.success) {\n        renderStatus(data.license);\n        updateHeaderBadge(data.license);\n      }\n    } catch (e) {\n      console.warn('Failed to load license status:', e.message);\n    }\n  }\n\n  async function activateLicense() {\n    const code = codeInput.value.trim();\n    if (!code) {\n      showError('Please enter a license code.');\n      return;\n    }\n\n    hideMessages();\n    activateBtn.disabled = true;\n    activateBtn.textContent = 'Activating...';\n\n    try {\n      const resp = await secureFetch('/api/v1/license/activate', {\n        method: 'POST',\n        headers: { 'Content-Type': 'application/json' },\n        body: JSON.stringify({ code })\n      });\n      const data = await resp.json();\n\n      if (data.success) {\n        showSuccess(data.message);\n        codeInput.value = '';\n        renderStatus(data.license);\n        showNotification('License activated! Premium features unlocked.', 'success', 5000);\n        updateHeaderBadge(data.license);\n      } else {\n        showError(data.error || 'Activation failed');\n      }\n    } catch (e) {\n      showError('Network error: ' + e.message);\n    } finally {\n      activateBtn.disabled = false;\n      activateBtn.textContent = 'Activate';\n    }\n  }\n\n  async function deactivateLicense() {\n    if (!confirm('Deactivate your license? You can reuse the code on another machine.')) return;\n\n    deactivateBtn.disabled = true;\n    deactivateBtn.textContent = 'Deactivating...';\n\n    try {\n      const resp = await secureFetch('/api/v1/license/deactivate', { method: 'POST' });\n      const data = await resp.json();\n\n      if (data.success) {\n        showSuccess(data.message);\n        await loadStatus();\n        showNotification('License deactivated.', 'info', 3000);\n        updateHeaderBadge({ active: false });\n      } else {\n        showError(data.error || 'Deactivation failed');\n      }\n    } catch (e) {\n      showError('Network error: ' + e.message);\n    } finally {\n      deactivateBtn.disabled = false;\n      deactivateBtn.textContent = 'Deactivate';\n    }\n  }\n\n  function updateHeaderBadge(status) {\n    const topbar = document.getElementById('license-status-topbar');\n    const iconEl = document.getElementById('license-topbar-icon');\n    const textEl = document.getElementById('license-topbar-text');\n    const timeEl = document.getElementById('license-topbar-time');\n    if (!topbar) return;\n\n    topbar.className = 'license-status-topbar ' + (status.active ? 'premium' : 'free');\n\n    if (status.active) {\n      iconEl.textContent = '\\u2605';\n      textEl.textContent = 'PREMIUM';\n      if (status.lifetime) {\n        timeEl.textContent = '\\u00b7 LIFETIME';\n      } else {\n        const days = status.daysRemaining;\n        timeEl.textContent = days != null ? '\\u00b7 ' + days + 'd remaining' : '';\n      }\n    } else {\n      iconEl.textContent = '\\u2606';\n      textEl.textContent = status.expired ? 'EXPIRED' : 'FREE TIER';\n      timeEl.textContent = '';\n    }\n  }\n\n  function openLicenseModal() {\n    hideMessages();\n    loadStatus();\n    modal.classList.add('show');\n  }\n\n  // Format code input as user types (auto-add dashes)\n  codeInput.addEventListener('input', function() {\n    let val = this.value.toUpperCase().replace(/[^A-Z0-9-]/g, '');\n    // Don't auto-format if user is deleting\n    if (val.length > this._prevLength) {\n      val = val.replace(/-/g, '');\n      if (val.length > 2 && !val.startsWith('DC')) {\n        val = 'DC' + val;\n      }\n      // Add dashes after DC and every 5 chars\n      if (val.startsWith('DC') && val.length > 2) {\n        const parts = ['DC'];\n        const rest = val.substring(2);\n        for (let i = 0; i < rest.length; i += 5) {\n          parts.push(rest.substring(i, i + 5));\n        }\n        val = parts.join('-');\n      }\n    }\n    this._prevLength = val.length;\n    this.value = val;\n  });\n\n  // Wire up events\n  activateBtn.addEventListener('click', activateLicense);\n  deactivateBtn.addEventListener('click', deactivateLicense);\n  codeInput.addEventListener('keydown', (e) => {\n    if (e.key === 'Enter') activateLicense();\n  });\n  wireModal(modal, document.getElementById('license-cancel'));\n  const topbarEl = document.getElementById('license-status-topbar');\n  if (topbarEl) topbarEl.addEventListener('click', () => window.openLicenseModal && window.openLicenseModal());\n\n  // Expose for other modules to open\n  window.openLicenseModal = openLicenseModal;\n\n  // Expose feature check for frontend gating\n  window.checkPremiumFeature = async function(feature) {\n    try {\n      const resp = await fetch(`/api/v1/license/feature/${feature}`);\n      const data = await resp.json();\n      return data.available;\n    } catch {\n      return false;\n    }\n  };\n\n  // Load status on page load\n  loadStatus().then(status => {\n    if (currentStatus) updateHeaderBadge(currentStatus);\n  });\n})();\n;\n// Share Modal \u2014 DC-058\n//\n// Admin UI for DC-053 share routes. Opened from the \"Share\" button on each\n// service card (added in core/grid.js next to the existing options/delete\n// buttons). Two tabs:\n//   - Public link: pick a TTL (1h/24h/7d), POST /api/v1/share, render the\n//     returned urlPath with a copy button + revoke control.\n//   - Tailscale invite: enter an email, POST /api/v1/share/tailscale, render\n//     delivered status (inbox vs dev-console fallback vs URL fallback).\n//\n// Modal also lists outstanding shares for the selected service (GET /api/v1/share)\n// with revoke buttons. The list refreshes after every issue/revoke.\n//\n// Both issue endpoints are Pro-gated on the server \u2014 the modal surfaces a 402\n// as an upgrade prompt (\"Share is a Pro feature. Activate a license to unlock.\").\n// Tailscale invites additionally require tailscaleCoord configured on the host;\n// the server returns 400 with a clear message when missing.\n\n(function() {\n  'use strict';\n\n  if (window.__dc_058_share_modal_loaded) return;\n  window.__dc_058_share_modal_loaded = true;\n\n  const TTL_OPTIONS = [\n    { ms: 60 * 60 * 1000, label: '1 hour' },\n    { ms: 24 * 60 * 60 * 1000, label: '24 hours' },\n    { ms: 7 * 24 * 60 * 60 * 1000, label: '7 days' },\n  ];\n\n  injectModal('share-modal', `\n    <div id=\"share-modal\" class=\"weather-modal\" role=\"dialog\" aria-labelledby=\"share-modal-title\">\n      <div class=\"weather-modal-content\" style=\"min-width: 460px; max-width: 580px;\">\n        <h3 id=\"share-modal-title\">Share <span id=\"share-modal-service-name\">\u2026</span></h3>\n        <p style=\"font-size: 0.85rem; color: var(--muted); margin: 0 0 16px;\">\n          Create a public link or Tailscale invite so someone outside your network can access this service.\n        </p>\n\n        <div class=\"share-tabs\" style=\"display: flex; gap: 4px; margin-bottom: 16px; border-bottom: 1px solid var(--border);\">\n          <button class=\"share-tab active\" data-tab=\"public\" type=\"button\"\n            style=\"background: transparent; border: 0; border-bottom: 2px solid var(--accent); padding: 8px 14px; color: var(--fg); font-weight: 600; cursor: pointer;\">\n            Public link\n          </button>\n          <button class=\"share-tab\" data-tab=\"tailscale\" type=\"button\"\n            style=\"background: transparent; border: 0; border-bottom: 2px solid transparent; padding: 8px 14px; color: var(--muted); cursor: pointer;\">\n            Tailscale invite\n          </button>\n        </div>\n\n        <div class=\"share-tab-panel\" data-panel=\"public\">\n          <label class=\"form-label-bold\" for=\"share-public-ttl\">Link duration:</label>\n          <select id=\"share-public-ttl\" style=\"width: 100%; padding: 8px 10px; margin: 6px 0 12px; background: var(--input-bg); color: var(--fg); border: 1px solid var(--border); border-radius: 4px;\">\n            ${TTL_OPTIONS.map(o => `<option value=\"${o.ms}\">${o.label}</option>`).join('')}\n          </select>\n          <button id=\"share-public-create\" class=\"btn-accent\" type=\"button\"\n            style=\"width: 100%; padding: 10px; background: var(--accent); color: #04141f; border: 0; border-radius: 4px; font-weight: 600; cursor: pointer;\">\n            Create share link\n          </button>\n        </div>\n\n        <div class=\"share-tab-panel\" data-panel=\"tailscale\" style=\"display: none;\">\n          <label class=\"form-label-bold\" for=\"share-ts-email\">Recipient email:</label>\n          <input id=\"share-ts-email\" type=\"email\" placeholder=\"alice@example.com\" autocomplete=\"off\"\n            style=\"width: 100%; padding: 10px 12px; margin: 6px 0 12px; background: var(--card-bg); color: var(--fg); border: 1px solid var(--border); border-radius: 4px; font-size: 0.95rem;\" />\n          <p style=\"font-size: 0.8rem; color: var(--muted); margin: 0 0 12px;\">\n            A single-use Tailscale pre-auth key is generated and emailed. The device joins your tailnet and is routed to this service via Caddy.\n          </p>\n          <button id=\"share-ts-create\" class=\"btn-accent\" type=\"button\"\n            style=\"width: 100%; padding: 10px; background: var(--accent); color: #04141f; border: 0; border-radius: 4px; font-weight: 600; cursor: pointer;\">\n            Create Tailscale invite\n          </button>\n        </div>\n\n        <div id=\"share-issued\" style=\"display: none; margin-top: 16px; padding: 12px; background: var(--card-bg); border: 1px solid var(--border); border-radius: 6px;\">\n          <div style=\"font-size: 0.8rem; color: var(--muted); margin-bottom: 6px;\">Share link:</div>\n          <div style=\"display: flex; gap: 6px; align-items: center;\">\n            <input id=\"share-issued-url\" type=\"text\" readonly\n              style=\"flex: 1; padding: 8px 10px; background: var(--bg); color: var(--fg); border: 1px solid var(--border); border-radius: 4px; font-family: monospace; font-size: 0.85rem;\" />\n            <button id=\"share-issued-copy\" type=\"button\"\n              style=\"padding: 8px 14px; background: var(--accent); color: #04141f; border: 0; border-radius: 4px; font-weight: 600; cursor: pointer;\">\n              Copy\n            </button>\n          </div>\n          <div id=\"share-issued-meta\" style=\"font-size: 0.8rem; color: var(--muted); margin-top: 8px;\"></div>\n        </div>\n\n        <div id=\"share-error\" style=\"display: none; margin-top: 12px; padding: 10px; border-radius: 4px; background: rgba(231,76,60,0.15); color: var(--bad-fg); font-size: 0.85rem;\"></div>\n        <div id=\"share-success\" style=\"display: none; margin-top: 12px; padding: 10px; border-radius: 4px; background: rgba(46,204,113,0.15); color: var(--ok-fg); font-size: 0.85rem;\"></div>\n\n        <div id=\"share-outstanding\" style=\"margin-top: 16px;\">\n          <label class=\"form-label-bold\">Outstanding shares for this service</label>\n          <div id=\"share-outstanding-list\" style=\"margin-top: 6px; font-size: 0.85rem;\"></div>\n        </div>\n\n        <div class=\"weather-modal-buttons\" style=\"margin-top: 18px;\">\n          <button id=\"share-cancel\" type=\"button\">Close</button>\n        </div>\n      </div>\n    </div>\n  `);\n\n  const modal = document.getElementById('share-modal');\n  const serviceNameEl = document.getElementById('share-modal-service-name');\n  const issuedEl = document.getElementById('share-issued');\n  const issuedUrlInput = document.getElementById('share-issued-url');\n  const issuedCopyBtn = document.getElementById('share-issued-copy');\n  const issuedMetaEl = document.getElementById('share-issued-meta');\n  const errorEl = document.getElementById('share-error');\n  const successEl = document.getElementById('share-success');\n  const outstandingListEl = document.getElementById('share-outstanding-list');\n  const cancelBtn = document.getElementById('share-cancel');\n  const publicCreateBtn = document.getElementById('share-public-create');\n  const tsCreateBtn = document.getElementById('share-ts-create');\n  const tsEmailInput = document.getElementById('share-ts-email');\n  const publicTtlSelect = document.getElementById('share-public-ttl');\n\n  let currentService = null; // { id, name }\n  let activeTab = 'public';\n\n  function hideMessages() {\n    errorEl.style.display = 'none';\n    successEl.style.display = 'none';\n    issuedEl.style.display = 'none';\n  }\n\n  function showError(msg) {\n    successEl.style.display = 'none';\n    issuedEl.style.display = 'none';\n    errorEl.textContent = msg;\n    errorEl.style.display = 'block';\n  }\n\n  function showSuccess(msg) {\n    errorEl.style.display = 'none';\n    successEl.textContent = msg;\n    successEl.style.display = 'block';\n  }\n\n  function _originFromPage() {\n    // Build the absolute share URL from the page's current origin so the\n    // link is correct regardless of whether the user is on http://localhost\n    // (dev) or https://status.sami (prod). The urlPath returned by the API\n    // is a path-only string starting with /share/.\n    return window.location.origin;\n  }\n\n  function _absUrl(urlPath) {\n    if (urlPath.startsWith('http')) return urlPath;\n    return _originFromPage() + urlPath;\n  }\n\n  function _formatExpiry(iso) {\n    if (!iso) return '';\n    const d = new Date(iso);\n    if (Number.isNaN(d.getTime())) return '';\n    return d.toLocaleString();\n  }\n\n  function _formatRemaining(ms) {\n    if (ms <= 0) return 'expired';\n    const h = Math.floor(ms / 3600000);\n    if (h >= 24) return `${Math.floor(h / 24)}d ${h % 24}h left`;\n    const m = Math.floor((ms % 3600000) / 60000);\n    return `${h}h ${m}m left`;\n  }\n\n  function setActiveTab(name) {\n    activeTab = name;\n    hideMessages();\n    modal.querySelectorAll('.share-tab').forEach(btn => {\n      const isActive = btn.dataset.tab === name;\n      btn.classList.toggle('active', isActive);\n      btn.style.borderBottomColor = isActive ? 'var(--accent)' : 'transparent';\n      btn.style.color = isActive ? 'var(--fg)' : 'var(--muted)';\n      btn.style.fontWeight = isActive ? '600' : '400';\n    });\n    modal.querySelectorAll('.share-tab-panel').forEach(p => {\n      p.style.display = p.dataset.panel === name ? '' : 'none';\n    });\n  }\n\n  async function loadOutstanding() {\n    outstandingListEl.innerHTML = '<span style=\"color: var(--muted);\">Loading\u2026</span>';\n    try {\n      const resp = await fetch('/api/v1/share', { credentials: 'same-origin' });\n      if (!resp.ok) {\n        outstandingListEl.innerHTML = '<span style=\"color: var(--muted);\">No shares listed.</span>';\n        return;\n      }\n      const body = await resp.json();\n      const list = (body && body.data) || [];\n      const filtered = list.filter(s => s.serviceId === currentService.id);\n      if (filtered.length === 0) {\n        outstandingListEl.innerHTML = '<span style=\"color: var(--muted);\">No outstanding shares for this service.</span>';\n        return;\n      }\n      outstandingListEl.innerHTML = filtered.map(s => {\n        const remaining = s.expiresAt ? _formatRemaining(new Date(s.expiresAt).getTime() - Date.now()) : '';\n        return `\n          <div class=\"share-row\" data-share-id=\"${escapeHtml(s.id)}\"\n            style=\"display: flex; align-items: center; gap: 8px; padding: 6px 0; border-bottom: 1px dashed var(--border);\">\n            <span style=\"flex: 1;\">\n              <strong>${s.kind === 'tailscale' ? 'Tailscale' : 'Public'}</strong>\n              <span style=\"color: var(--muted);\"> \u00B7 expires ${escapeHtml(_formatExpiry(s.expiresAt))} (${remaining})</span>\n            </span>\n            <button class=\"share-revoke\" data-share-id=\"${escapeHtml(s.id)}\" type=\"button\"\n              style=\"padding: 4px 10px; background: transparent; color: var(--bad-fg); border: 1px solid var(--bad-fg); border-radius: 4px; cursor: pointer; font-size: 0.8rem;\">\n              Revoke\n            </button>\n          </div>\n        `;\n      }).join('');\n      outstandingListEl.querySelectorAll('.share-revoke').forEach(btn => {\n        btn.addEventListener('click', () => revokeShare(btn.dataset.shareId));\n      });\n    } catch (e) {\n      outstandingListEl.innerHTML = '<span style=\"color: var(--muted);\">Could not load outstanding shares.</span>';\n    }\n  }\n\n  async function revokeShare(id) {\n    try {\n      const resp = await fetch(`/api/v1/share/${encodeURIComponent(id)}`, {\n        method: 'DELETE',\n        credentials: 'same-origin',\n      });\n      if (!resp.ok) {\n        const body = await resp.json().catch(() => ({}));\n        showError(body && body.error || `Revoke failed (HTTP ${resp.status}).`);\n        return;\n      }\n      showSuccess('Share revoked.');\n      loadOutstanding();\n    } catch (e) {\n      showError('Network error while revoking.');\n    }\n  }\n\n  async function issuePublic() {\n    if (!currentService) return;\n    hideMessages();\n    publicCreateBtn.disabled = true;\n    const original = publicCreateBtn.textContent;\n    publicCreateBtn.textContent = 'Creating\u2026';\n    try {\n      const ttlMs = parseInt(publicTtlSelect.value, 10);\n      const resp = await fetch('/api/v1/share', {\n        method: 'POST',\n        credentials: 'same-origin',\n        headers: { 'Content-Type': 'application/json' },\n        body: JSON.stringify({ serviceId: currentService.id, ttlMs }),\n      });\n      const body = await resp.json().catch(() => ({}));\n      if (!resp.ok || !body.success) {\n        _renderApiError(resp.status, body);\n        return;\n      }\n      const urlPath = body.data.urlPath;\n      issuedUrlInput.value = _absUrl(urlPath);\n      issuedMetaEl.textContent = `Public link \u00B7 expires ${_formatExpiry(body.data.expiresAt)}`;\n      issuedEl.style.display = 'block';\n      showSuccess('Share link created.');\n      loadOutstanding();\n    } catch (e) {\n      showError('Network error while creating share.');\n    } finally {\n      publicCreateBtn.disabled = false;\n      publicCreateBtn.textContent = original;\n    }\n  }\n\n  async function issueTailscale() {\n    if (!currentService) return;\n    const email = (tsEmailInput.value || '').trim();\n    if (!email || !email.includes('@')) {\n      showError('A valid recipient email is required.');\n      return;\n    }\n    hideMessages();\n    tsCreateBtn.disabled = true;\n    const original = tsCreateBtn.textContent;\n    tsCreateBtn.textContent = 'Creating\u2026';\n    try {\n      const resp = await fetch('/api/v1/share/tailscale', {\n        method: 'POST',\n        credentials: 'same-origin',\n        headers: { 'Content-Type': 'application/json' },\n        body: JSON.stringify({ serviceId: currentService.id, email }),\n      });\n      const body = await resp.json().catch(() => ({}));\n      if (!resp.ok || !body.success) {\n        _renderApiError(resp.status, body);\n        return;\n      }\n      // Tailscale shares show the raw urlPath (which is the share URL) if\n      // email delivery failed. The share itself is one-shot so the admin\n      // can manually paste the link into a chat if SMTP failed.\n      const fallback = body.data && body.data.urlPath;\n      if (fallback) {\n        issuedUrlInput.value = _absUrl(fallback);\n        issuedMetaEl.textContent = `Tailscale invite \u00B7 emailed to ${email} (or use this URL manually if delivery failed).`;\n      } else {\n        issuedUrlInput.value = '';\n        issuedMetaEl.textContent = `Tailscale invite sent to ${email}.`;\n      }\n      issuedEl.style.display = 'block';\n      showSuccess('Tailscale invite created.');\n      tsEmailInput.value = '';\n      loadOutstanding();\n    } catch (e) {\n      showError('Network error while creating Tailscale invite.');\n    } finally {\n      tsCreateBtn.disabled = false;\n      tsCreateBtn.textContent = original;\n    }\n  }\n\n  function _renderApiError(status, body) {\n    const err = (body && body.error) || '';\n    if (status === 402) {\n      showError('Share is a Pro feature. Activate a license to unlock.');\n      return;\n    }\n    if (status === 400 && /tailscale/i.test(err)) {\n      showError('Tailscale is not configured on this host. Set up Tailscale in the dashboard first.');\n      return;\n    }\n    if (status === 403) {\n      showError('You do not have permission to share services.');\n      return;\n    }\n    if (status === 404) {\n      showError('Service not found. It may have been deleted.');\n      return;\n    }\n    showError(err || `Request failed (HTTP ${status}).`);\n  }\n\n  function openShareModal(service) {\n    if (!service || !service.id) return;\n    currentService = { id: service.id, name: service.name || service.id };\n    serviceNameEl.textContent = currentService.name;\n    hideMessages();\n    setActiveTab('public');\n    tsEmailInput.value = '';\n    publicTtlSelect.value = String(TTL_OPTIONS[1].ms); // 24h default\n    modal.classList.add('show');\n    loadOutstanding();\n  }\n\n  // Wire events\n  modal.querySelectorAll('.share-tab').forEach(btn => {\n    btn.addEventListener('click', () => setActiveTab(btn.dataset.tab));\n  });\n  publicCreateBtn.addEventListener('click', issuePublic);\n  tsCreateBtn.addEventListener('click', issueTailscale);\n  cancelBtn.addEventListener('click', () => modal.classList.remove('show'));\n  wireModal(modal, cancelBtn);\n\n  // Copy-to-clipboard for the issued share URL\n  issuedCopyBtn.addEventListener('click', async () => {\n    const url = issuedUrlInput.value;\n    if (!url) return;\n    try {\n      if (navigator.clipboard && navigator.clipboard.writeText) {\n        await navigator.clipboard.writeText(url);\n      } else {\n        // Fallback for older browsers / unsafe contexts\n        issuedUrlInput.select();\n        document.execCommand('copy');\n      }\n      const original = issuedCopyBtn.textContent;\n      issuedCopyBtn.textContent = 'Copied!';\n      setTimeout(() => { issuedCopyBtn.textContent = original; }, 1200);\n    } catch (e) {\n      showError('Could not copy to clipboard. Select the URL manually.');\n    }\n  });\n\n  // Expose for other modules to open\n  window.openShareModal = openShareModal;\n})();\n"],
  "mappings": "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",
  "names": ["logoModal", "previewDark", "previewLight", "logoStatus", "sameBothCheckbox", "dualUploads", "singleUpload", "uploadDark", "uploadLight", "uploadSingle", "brandLogoDark", "brandLogoLight", "topRow", "dashboardTitleInput", "DEFAULT_TITLE", "pendingDarkData", "pendingLightData", "pendingSingleData", "currentPosition", "currentTitle", "readFileAsDataURL", "file", "callback", "reader", "e", "data", "applyLogoPosition", "pos", "btn", "applyDashboardTitle", "title", "headerTitle", "loadCustomLogo", "response", "error", "isCustom", "newTitle", "payload", "t", "faviconLink", "faviconPreview", "faviconStatus", "pendingFaviconData", "faviconUpload", "loadCustomFavicon", "event", "settingsTzSelect", "currentTz", "res", "tz", "cfg", "selectEl", "selectedTz", "timezones", "detected", "opt", "currentConfigType", "serverConfig", "checkServerConfig", "setupTzSelect", "showStep", "stepId", "step", "targetStep", "showSummary", "summaryContent", "html", "tld", "caName", "dnsIP", "dnsPort", "ip", "domain", "email", "routingMode", "exampleUrls", "saveConfigToServer", "config", "finishSetup", "selectedProvider", "savedToServer", "configName", "saveLocation", "step1Next", "selected", "skipBtn", "tldInput", "preview1", "preview2", "homelabBack", "homelabNext", "simpleBack", "simpleNext", "radio", "note", "publicBack", "publicNext", "summaryBack", "summaryNext", "diskSafetyBack", "finishBtn", "configStr", "errorHandler", "APPS_KEY", "apiTemplates", "apiCategories", "modal", "grid", "fetchAppTemplates", "checkPortAvailability", "port", "getSuggestedPort", "basePort", "buildAppSelector", "byCategory", "appId", "template", "category", "categoryOrder", "apps", "a", "b", "header", "categoryInfo", "app", "option", "isWidget", "widgetEnabled", "widgetBadge", "difficultyBadge", "toggleDashboardWidget", "showDeployConfig", "optionEl", "key", "newState", "selector", "el", "badge", "appTemplate", "deployModal", "subdomainInput", "urlPreview", "ipInput", "portInput", "tailscaleCheckbox", "tailscaleStatus", "checkResult", "container", "defaultSubdomain", "subpathWarning", "support", "cfgDnsType", "cfgSslType", "dnsRadio", "sslRadio", "dnsSection", "advancedDetails", "advancedContent", "dnsSectionEl", "sslSectionEl", "mediaPathSection", "mediaPathInput", "mediaPathDescription", "detectedMountsContainer", "detectedMountsList", "mountsResult", "autoPaths", "m", "mount", "isSelected", "currentPaths", "p", "idx", "plexClaimSection", "volumeSection", "volumeList", "mediaContainerPath", "nonMediaVolumes", "v", "vol", "i", "hostDefault", "containerPath", "row", "input", "defaultPort", "portStatus", "checkAndUpdatePortStatus", "portToCheck", "result", "suggestedPort", "useBtn", "portCheckTimeout", "updateUrlPreview", "subdomain", "dnsType", "sslType", "url", "protocol", "addAppToGrid", "deployConfig", "customApps", "usingExisting", "existingApp", "index", "portToUse", "portCheck", "apiDeployConfig", "catalogPayload", "newApp", "message", "checkSSLCertificate", "instructions", "appName", "attempts", "maxAttempts", "checkCert", "loadCustomApps", "mediaPath", "customVolumes", "folderBrowserModal", "folderBrowserPath", "folderBrowserList", "folderBrowserSelected", "folderBrowserSelectedList", "currentBrowserPath", "selectedFolders", "targetMediaInput", "mediaInput", "updateSelectedFoldersDisplay", "loadFolderContents", "path", "item", "icon", "selectedStyle", "recipeTemplates", "recipeCategories", "currentRecipe", "currentStep", "isPremium", "cancelBtn", "prevBtn", "nextBtn", "fetchRecipeTemplates", "resp", "checkRecipePremium", "recipes", "getPreviewRecipes", "recipeList", "recipe", "componentBadge", "lockOverlay", "openRecipeDeployWizard", "appSelectorModal", "updateStepUI", "renderStep1", "panel", "list", "components", "comp", "isRequired", "isInternal", "renderStep2", "sharedVolumes", "renderStep3", "content", "selectedComponents", "getSelectedComponents", "volumeInputs", "volumes", "tailscale", "c", "k", "checkboxes", "selectedIds", "cb", "executeDeploy", "progressList", "resultEl", "updateProgressItem", "deployed", "err", "s", "componentId", "status", "text", "statusEl", "cards", "groups", "card", "recipeId", "groupCards", "label", "action", "endpoint", "method", "r", "style", "button", "originalText", "viewBtn", "refreshBtn", "clearBtn", "closeBtn", "levelSel", "contextSel", "searchInput", "sinceInput", "untilInput", "loadMoreBtn", "totalSpan", "PAGE_SIZE", "currentOffset", "inflight", "filterNonce", "knownContexts", "toIso", "localDtValue", "d", "refreshContexts", "currentValue", "buildQuery", "params", "since", "until", "search", "loadLogs", "append", "myNonce", "logs", "reason", "log", "level", "levelColor", "ts", "ctx", "msg", "table", "detail", "clearLogs", "searchDebounce", "wireFilters", "dateDebounce", "containerSelect", "logContent", "logSearch", "logTail", "streamBtn", "downloadBtn", "clearSearchBtn", "closeBtn2", "streamStatus", "streamIndicator", "streamText", "lineCount", "filterCount", "imageEl", "createdEl", "currentContainerId", "currentLogs", "filteredLogs", "eventSource", "isStreaming", "searchTimeout", "formatDate", "dateStr", "escapeHtml", "str", "div", "formatLogEntry", "streamClass", "streamIcon", "renderLogs", "searchTerm", "loadContainers", "containers", "currentVal", "loadContainerInfo", "containerId", "stopStream", "tail", "startStream", "entry", "entryDiv", "downloadLogs", "containerName", "timestamp", "filename", "stream", "blob", "closeModal", "UNIT_PRESETS", "unitSelect", "tailInput", "clearSearch", "overflowHint", "unitDisplay", "streamState", "available", "lines", "streaming", "searchTimer", "setAvailable", "isAvailable", "probeAvailable", "renderLines", "term", "filtered", "l", "line", "loadTail", "unit", "ev", "close", "openJournaldModal", "openBtn", "detailsDiv", "createBtn", "createStatus", "showContainerDetails", "createSnapshot", "name", "leaveRunning", "openModal", "tab", "connectBtn", "phaseDetect", "phaseCredentials", "phaseProgress", "phaseResults", "detectResults", "credentialInputs", "progressSteps", "resultsContent", "plexLibraries", "retryBtn", "detectedData", "serviceIcons", "serviceLabels", "showPhase", "phase", "statusBadge", "colors", "smartDetect", "svc", "info", "source", "version", "keySaved", "buildCredentialInputs", "services", "arrServices", "isConnected", "plex", "plexConnected", "seerr", "seerrOk", "configuredHtml", "cs", "service", "urlInput", "keyInput", "statusSpan", "apiKey", "smartConnect", "stepsHtml", "detailColor", "showResults", "allGood", "headerColor", "headerIcon", "headerText", "st", "fetchPlexLibraries", "lib", "typeIcon", "saveBtn", "provider", "checkbox", "healthCheckEnabled", "healthCheckConfig", "loadNotificationConfig", "emailPassEl", "loadNotificationHistory", "date", "saveNotificationConfig", "testProvider", "loadNotificationStatus", "lastSentEl", "panelId", "tabBar", "modalContent", "target", "BROWSER_STATE_KEYS", "collectBrowserState", "state", "val", "j", "restoreBrowserState", "browserState", "count", "isLegacyFormat", "restoreLegacyFormat", "slug", "exportBtn", "selectFileBtn", "fileInput", "fileNameDiv", "previewDiv", "previewContent", "restoreBtn", "resultDiv", "scheduleContainer", "historyContainer", "diskContainer", "pointintimeContainer", "selectedBackup", "stateCount", "themeCount", "backup", "preview", "reloadCaddy", "browserCount", "loadSchedulesTab", "schedules", "sch", "nextRunStr", "lastRunStr", "toggle", "updateSchedule", "sel", "inp", "runBackupNow", "deleteSchedule", "addNewSchedule", "updates", "interval", "retention", "appIdInput", "loadDiskBackups", "files", "byApp", "f", "appIds", "appFiles", "compareBackupFile", "restoreBackupFile", "loadBackupHistory", "bk", "sizeMB", "backupId", "loadPointInTimeTab", "licenseRes", "licenseData", "servicesRes", "servicesData", "loadPointInTimeBackups", "listEl", "diff", "svcChanged", "cfgChanged", "autoRefreshCheckbox", "aggregatedContainer", "alertsContainer", "lastUpdateSpan", "refreshInterval", "cachedMonitoringData", "formatBytes", "bytes", "sizes", "getCpuColor", "percent", "getMemColor", "loadStats", "stats", "isNewApi", "id", "cur", "cpu", "mem", "cpuColor", "memColor", "memUsed", "memLimit", "netRx", "netTx", "agg", "loadAggregated", "loadAlerts", "alertHistory", "hd", "allConfigs", "cd", "containerRows", "historyRows", "time", "notifiedMark", "configSection", "configs", "cId", "stopAutoRefresh", "orig", "startAutoRefresh", "historyContainerSelect", "historyArea", "rangeButtons", "currentRange", "rangeToMs", "range", "tierLabel", "tier", "renderSparkline", "samples", "accessor", "color", "values", "max", "min", "w", "h", "pad", "stepX", "points", "x", "y", "last", "avg", "populateHistoryContainerSelect", "previous", "entries", "loadHistory", "endTime", "startTime", "isRaw", "cpuAccessor", "memAccessor", "netRxAccessor", "netTxAccessor", "statusContainer", "incidentsContainer", "configContainer", "addBtn", "formEl", "formTitle", "formCancel", "formSave", "HEALTH_SETTINGS_KEY", "HEALTH_DEFAULTS", "globalSaveBtn", "globalResetBtn", "globalStatusSpan", "retentionInput", "intervalInput", "statsIntervalInput", "maxEntriesInput", "diskThresholdInput", "loadHealthSettings", "raw", "saved", "applyHealthSettingsToUI", "saveHealthSettings", "settings", "resetHealthSettings", "editingId", "uptimeColor", "pct", "severityBadge", "sev", "loadStatus", "isUp", "dotColor", "u24", "u7d", "avgRt", "lastCheck", "detailRow", "rt", "loadIncidents", "openRes", "histRes", "openData", "histData", "open", "inc", "history", "resolved", "dur", "loadConfig", "showForm", "timeout", "codes", "sla", "slow", "hideForm", "body", "checkBtn", "availableContainer", "autoContainer", "lastCheckSpan", "loadAvailable", "u", "countBadge", "updateAllBtn", "updateAllContainers", "success", "failed", "checkForUpdates", "ok", "loadAutoConfig", "containersRes", "configRes", "containersData", "configData", "savedConfig", "cid", "scheduleVal", "rollbackVal", "windowVal", "lastRun", "schedule", "rollback", "window", "dcVersionInfo", "dcUpdateBadge", "dcUpdateDetails", "dcNewVersion", "dcChangelog", "dcApplyBtn", "dcCheckBtn", "dcRollbackBtn", "dcStatusBar", "dcHistoryContainer", "dcLastCheck", "dcShowStatus", "type", "dcLoadVersion", "commit", "dcCheckForUpdate", "silent", "updatesBtn", "dot", "dcTab", "dcApplyUpdate", "dcLoadHistory", "stColor", "dcShowRollback", "versions", "fmtBytes", "units", "loadVolumes", "vols", "isSystem", "nameInput", "loadNetworks", "nets", "n", "driverSelect", "loadDiskUsage", "sections", "parsedData", "yamlStr", "stackName", "origText", "renderPreview", "borderColor", "parts", "progressEl", "termEl", "ws", "fitAddon", "cleanup", "openExec", "dims", "cols", "rows", "resizeHandler", "filterSelect", "outcomeSelect", "loadAudit", "outcome", "actor", "actorLabel", "role", "tag", "tabs", "panels", "allEvents", "allHosts", "sseSource", "refreshOverview", "refreshEvents", "refreshHosts", "startLiveTail", "stopLiveTail", "renderEvents", "active", "statsRes", "hostsRes", "eventsRes", "hosts", "eventsCount", "renderTopList", "items", "it", "filterSource", "filterSeverity", "filterHost", "filterActor", "debounce", "refreshHostFilter", "renderEventRow", "sevColor", "current", "registerHostPrompt", "fn", "ms", "repos", "escFn", "anonymous", "typed", "$", "loadedOnce", "esc", "api", "opts", "showOutput", "loadServices", "loadRepos", "loadJournal", "qs", "loadGiteaRepos", "hostEl", "tokEl", "anonEl", "runInstall", "repoUrl", "argsRaw", "args", "setBusy", "typedToken", "requestToken", "busy", "runDeploy", "dir", "runRollback", "runStatus", "wire", "rb", "sb", "LOCATION_KEY", "LEGACY_KEY", "GEO_CACHE_KEY", "UNIT_KEY", "getUnit", "getWeatherElements", "wmoDescriptions", "wmoIcons", "windDirs", "degToDir", "deg", "geocodeLocation", "query", "cached", "geo", "formatLocation", "fetchWeather", "location", "tempUnit", "windUnit", "code", "updateWeather", "weatherWidget", "weather", "tempSuffix", "windLabel", "locationInput", "loc", "unitRadio", "newUnit", "oldUnit", "widget", "render", "DAYS", "MONTHS", "ROMAN", "currentStyle", "lastChimeHour", "chimePlaying", "prevFlipDigits", "activeLayout", "digitalRefs", "tickTimer", "playChimes", "strike", "bell", "now", "resetRenderLayout", "ensureDigitalLayout", "renderDefault", "h24", "ampm", "refs", "renderLcd", "cls", "renderFlip", "digits", "flipCard", "digit", "renderBinary", "bit", "col", "on", "renderAnalog", "useRoman", "size", "cx", "cy", "sAngle", "mAngle", "hAngle", "labels", "angle", "ticks", "outer", "inner", "x1", "y1", "x2", "y2", "svg", "tick", "nextClassName", "scheduleNextTick", "delay", "STYLES", "styleOptionsHtml", "chimesToggle", "volumeSlider", "loadSettings", "widgetEls", "fmtWhen", "start", "allDay", "today", "day", "days", "dayLabel", "timeLabel", "fetchCalendar", "end", "renderWidget", "els", "events", "next", "renderUpcoming", "renderSources", "sources", "enable", "refresh", "formCreds", "setStatus", "calBtn", "calSettings", "calClose", "POLL", "loadInfo", "loadConnections", "keys", "createConnection", "client", "snippet", "copyText", "okMsg", "refreshCardHealth", "serviceId", "uptimeEl", "barEl", "uptime24", "dismissedUpdates", "knownUpdates", "refreshCardUpdates", "notifyNew", "prev", "upd", "updateBtn", "scheduleCardEnhancements", "origRefreshAll", "themeBeforeBuilder", "editingSlug", "advancedOverrides", "THEME_LABELS", "FIELDS", "themeBtn", "themeLabel", "getLabelFor", "userThemes", "updateLabel", "buildFieldsHTML", "grouped", "buildStartFromOptions", "modalHTML", "startSelect", "editSelect", "existingSection", "lightBgCheck", "pickers", "advancedSection", "advancedToggle", "advancedVisible", "getCurrentColors", "getBaseColors", "updateAdvancedFromDerived", "base", "derived", "hex", "loadThemeIntoPickers", "themeName", "updatePreview", "loadUserThemeIntoPickers", "theme", "muted", "badgeOk", "badgeBad", "dotOk", "dotBad", "dots", "applyColorsLive", "prop", "refreshEditDropdown", "slugs", "refreshStartFrom", "openBuilder", "customizeBtn", "oldSlug", "newSlug", "themeData", "apiColors", "slugToDelete", "fallback", "exportData", "themeColors", "themeLightBg", "codeInput", "activateBtn", "deactivateBtn", "errorEl", "successEl", "badgeIcon", "badgeText", "detailsEl", "featureList", "activateSection", "currentStatus", "hideMessages", "showError", "showSuccess", "renderStatus", "expiryLine", "features", "activeFeatures", "updateHeaderBadge", "activateLicense", "deactivateLicense", "topbar", "iconEl", "textEl", "timeEl", "openLicenseModal", "rest", "topbarEl", "feature", "TTL_OPTIONS", "o", "serviceNameEl", "issuedEl", "issuedUrlInput", "issuedCopyBtn", "issuedMetaEl", "outstandingListEl", "publicCreateBtn", "tsCreateBtn", "tsEmailInput", "publicTtlSelect", "currentService", "activeTab", "_originFromPage", "_absUrl", "urlPath", "_formatExpiry", "iso", "_formatRemaining", "setActiveTab", "isActive", "loadOutstanding", "remaining", "revokeShare", "issuePublic", "original", "ttlMs", "_renderApiError", "issueTailscale", "openShareModal"]
}

+        `}).join(""),$.querySelectorAll(".share-revoke").forEach(r=>{r.addEventListener("click",()=>o(r.dataset.shareId))})}catch{$.innerHTML='<span style="color: var(--muted);">Could not load outstanding shares.</span>'}}async function o(t){try{const e=await fetch(`/api/v1/share/${encodeURIComponent(t)}`,{method:"DELETE",credentials:"same-origin"});if(!e.ok){const s=await e.json().catch(()=>({}));v(s&&s.error||`Revoke failed (HTTP ${e.status}).`);return}S("Share revoked."),L()}catch{v("Network error while revoking.")}}async function u(){if(!M)return;d(),H.disabled=!0;const t=H.textContent;H.textContent="Creating\u2026";try{const e=parseInt(C.value,10),s=await fetch("/api/v1/share",{method:"POST",credentials:"same-origin",headers:{"Content-Type":"application/json"},body:JSON.stringify({serviceId:M.id,ttlMs:e})}),n=await s.json().catch(()=>({}));if(!s.ok||!n.success){g(s.status,n);return}const r=n.data.urlPath;P.value=m(r),D.textContent=`Public link \xB7 expires ${f(n.data.expiresAt)}`,h.style.display="block",S("Share link created."),L()}catch{v("Network error while creating share.")}finally{H.disabled=!1,H.textContent=t}}async function l(){if(!M)return;const t=(z.value||"").trim();if(!t||!t.includes("@")){v("A valid recipient email is required.");return}d(),T.disabled=!0;const e=T.textContent;T.textContent="Creating\u2026";try{const s=await fetch("/api/v1/share/tailscale",{method:"POST",credentials:"same-origin",headers:{"Content-Type":"application/json"},body:JSON.stringify({serviceId:M.id,email:t})}),n=await s.json().catch(()=>({}));if(!s.ok||!n.success){g(s.status,n);return}const r=n.data&&n.data.urlPath;r?(P.value=m(r),D.textContent=`Tailscale invite \xB7 emailed to ${t} (or use this URL manually if delivery failed).`):(P.value="",D.textContent=`Tailscale invite sent to ${t}.`),h.style.display="block",S("Tailscale invite created."),z.value="",L()}catch{v("Network error while creating Tailscale invite.")}finally{T.disabled=!1,T.textContent=e}}function g(t,e){const s=e&&e.error||"";if(t===402){v("Share is a Pro feature. Activate a license to unlock.");return}if(t===400&&/tailscale/i.test(s)){v("Tailscale is not configured on this host. Set up Tailscale in the dashboard first.");return}if(t===403){v("You do not have permission to share services.");return}if(t===404){v("Service not found. It may have been deleted.");return}v(s||`Request failed (HTTP ${t}).`)}function p(t){!t||!t.id||(M={id:t.id,name:t.name||t.id},j.textContent=M.name,d(),w("public"),z.value="",C.value=String(x[1].ms),E.classList.add("show"),L())}E.querySelectorAll(".share-tab").forEach(t=>{t.addEventListener("click",()=>w(t.dataset.tab))}),H.addEventListener("click",u),T.addEventListener("click",l),k.addEventListener("click",()=>E.classList.remove("show")),wireModal(E,k),A.addEventListener("click",async()=>{const t=P.value;if(t)try{navigator.clipboard&&navigator.clipboard.writeText?await navigator.clipboard.writeText(t):(P.select(),document.execCommand("copy"));const e=A.textContent;A.textContent="Copied!",setTimeout(()=>{A.textContent=e},1200)}catch{v("Could not copy to clipboard. Select the URL manually.")}}),window.openShareModal=p})();
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["<stdin>"],
  "sourcesContent": ["// Logo Customization System\n(function() {\n  // Inject modal HTML\n  injectModal('logo-modal', `<div id=\"logo-modal\" class=\"weather-modal\">\n    <div class=\"weather-modal-content\" style=\"min-width: 400px; max-width: 520px;\">\n      <h3>Dashboard Settings</h3>\n      <p style=\"font-size: 0.85rem; color: var(--muted); margin: 0 0 16px;\">\n        Customize your dashboard's appearance and system preferences.\n      </p>\n\n      <div class=\"mb-16\">\n        <label for=\"dashboard-title\" class=\"form-label-bold\">Dashboard Title:</label>\n        <input type=\"text\" id=\"dashboard-title\" placeholder=\"DashCaddy\" maxlength=\"50\" style=\"width: 100%; padding: 10px 12px; border: 1px solid var(--border); border-radius: 4px; background: var(--card-bg); color: var(--fg); font-size: 1rem;\" />\n        <p class=\"tiny-hint\">Shown in browser tab and header (max 50 characters)</p>\n      </div>\n\n      <hr class=\"hr-divider\" />\n\n      <div class=\"mb-16\">\n        <label class=\"form-label-bold\">Logo:</label>\n        <p class=\"tiny-hint\" style=\"margin-top: 2px;\">Separate logos for dark and light themes, or use the same for both.</p>\n      </div>\n\n      <div style=\"display: flex; gap: 12px; margin-bottom: 12px;\">\n        <div style=\"flex: 1; text-align: center; padding: 16px 10px; border-radius: 8px; background: #1a1a2e; border: 1px solid rgba(255,255,255,.1);\">\n          <img id=\"logo-preview-dark\" src=\"/assets/dashcaddy-logo-dark.png\" alt=\"Dark theme logo\" style=\"max-height: 60px; max-width: 100%;\" />\n          <p style=\"font-size: 0.65rem; color: #9aa6bf; margin-top: 6px;\">Dark themes</p>\n        </div>\n        <div style=\"flex: 1; text-align: center; padding: 16px 10px; border-radius: 8px; background: #f0f0f0; border: 1px solid rgba(0,0,0,.1);\">\n          <img id=\"logo-preview-light\" src=\"/assets/dashcaddy-logo-light.png\" alt=\"Light theme logo\" style=\"max-height: 60px; max-width: 100%;\" />\n          <p style=\"font-size: 0.65rem; color: #5f6b7a; margin-top: 6px;\">Light themes</p>\n        </div>\n      </div>\n      <p id=\"logo-status\" style=\"font-size: 0.75rem; color: var(--muted); margin-bottom: 12px; text-align: center;\">Using default logos</p>\n\n      <div class=\"mb-16\">\n        <label style=\"display: flex; align-items: center; gap: 8px; font-size: 0.82rem; cursor: pointer; user-select: none;\">\n          <input type=\"checkbox\" id=\"logo-same-both\" /> Use same logo for both\n        </label>\n      </div>\n\n      <div id=\"logo-dual-uploads\" class=\"mb-16\" style=\"display: flex; gap: 12px;\">\n        <div style=\"flex: 1;\">\n          <label for=\"logo-upload-dark\" style=\"display: block; margin-bottom: 6px; font-size: 0.8rem;\">Dark theme logo:</label>\n          <input type=\"file\" id=\"logo-upload-dark\" accept=\"image/*\" class=\"input-card-alt\" style=\"font-size: 0.75rem;\" />\n        </div>\n        <div style=\"flex: 1;\">\n          <label for=\"logo-upload-light\" style=\"display: block; margin-bottom: 6px; font-size: 0.8rem;\">Light theme logo:</label>\n          <input type=\"file\" id=\"logo-upload-light\" accept=\"image/*\" class=\"input-card-alt\" style=\"font-size: 0.75rem;\" />\n        </div>\n      </div>\n\n      <div id=\"logo-single-upload\" class=\"mb-16\" style=\"display: none;\">\n        <label for=\"logo-upload-single\" style=\"display: block; margin-bottom: 6px; font-size: 0.8rem;\">Upload logo:</label>\n        <input type=\"file\" id=\"logo-upload-single\" accept=\"image/*\" class=\"input-card-alt\" />\n        <p class=\"tiny-hint\">This logo will be used on all themes</p>\n      </div>\n\n      <div class=\"mb-16\">\n        <label style=\"display: block; margin-bottom: 8px;\">Logo Position:</label>\n        <div id=\"logo-position-btns\" class=\"flex-row-gap\">\n          <button type=\"button\" data-pos=\"left\" class=\"logo-pos-btn btn-option\">Left</button>\n          <button type=\"button\" data-pos=\"center\" class=\"logo-pos-btn btn-option\">Center</button>\n          <button type=\"button\" data-pos=\"right\" class=\"logo-pos-btn btn-option\">Right</button>\n        </div>\n      </div>\n\n      <hr class=\"hr-divider\" />\n\n      <div class=\"mb-16\">\n        <label class=\"form-label-bold\">Favicon (Browser Tab Icon):</label>\n        <div id=\"favicon-preview-container\" style=\"display: flex; align-items: center; gap: 12px; margin-bottom: 8px; padding: 12px; border-radius: 6px; background: var(--card-bg);\">\n          <img id=\"favicon-preview\" src=\"/assets/dashcaddy-favicon.ico\" alt=\"Current favicon\" style=\"width: 32px; height: 32px; image-rendering: pixelated;\" onerror=\"this.src='data:image/svg+xml,<svg xmlns=%22http://www.w3.org/2000/svg%22 viewBox=%220 0 32 32%22><rect fill=%22%23667%22 width=%2232%22 height=%2232%22 rx=%224%22/></svg>'\" />\n          <span id=\"favicon-status\" class=\"text-tiny-muted\">Using DashCaddy favicon</span>\n        </div>\n        <input type=\"file\" id=\"favicon-upload\" accept=\"image/png,image/svg+xml\" class=\"input-card-alt\" />\n        <p class=\"tiny-hint\">Upload PNG or SVG - automatically converted to ICO</p>\n      </div>\n\n      <hr class=\"hr-divider\" />\n\n      <div class=\"mb-16\">\n        <label for=\"settings-timezone\" class=\"form-label-bold\">Timezone:</label>\n        <select id=\"settings-timezone\" style=\"width: 100%; padding: 10px 12px; border: 1px solid var(--border); border-radius: 4px; background: var(--card-bg); color: var(--fg); font-size: 1rem;\">\n          <!-- Populated by JS with IANA timezones -->\n        </select>\n        <p class=\"tiny-hint\">Used by all deployed containers. Changes apply to new deployments.</p>\n      </div>\n\n      <div class=\"weather-modal-buttons\">\n        <button id=\"logo-reset\" style=\"background: color-mix(in srgb, #ef4444 20%, transparent); border-color: #ef4444; color: #ef4444;\">Reset to Default</button>\n        <button id=\"logo-cancel\">Cancel</button>\n        <button id=\"logo-save\" class=\"btn-accent\">Save</button>\n      </div>\n    </div>\n  </div>`);\n\n  const logoModal = document.getElementById('logo-modal');\n  const previewDark = document.getElementById('logo-preview-dark');\n  const previewLight = document.getElementById('logo-preview-light');\n  const logoStatus = document.getElementById('logo-status');\n  const sameBothCheckbox = document.getElementById('logo-same-both');\n  const dualUploads = document.getElementById('logo-dual-uploads');\n  const singleUpload = document.getElementById('logo-single-upload');\n  const uploadDark = document.getElementById('logo-upload-dark');\n  const uploadLight = document.getElementById('logo-upload-light');\n  const uploadSingle = document.getElementById('logo-upload-single');\n  const brandLogoDark = document.querySelector('#brand .brand-logo-dark');\n  const brandLogoLight = document.querySelector('#brand .brand-logo-light');\n  const topRow = document.querySelector('.top-row');\n  const dashboardTitleInput = document.getElementById('dashboard-title');\n  const DEFAULT_TITLE = DC.NAME;\n\n  let pendingDarkData = null;\n  let pendingLightData = null;\n  let pendingSingleData = null;\n  let currentPosition = 'left';\n  let currentTitle = DEFAULT_TITLE;\n\n  // Toggle between dual and single upload mode\n  sameBothCheckbox?.addEventListener('change', () => {\n    if (sameBothCheckbox.checked) {\n      dualUploads.style.display = 'none';\n      singleUpload.style.display = '';\n      // Clear individual pending data\n      pendingDarkData = null;\n      pendingLightData = null;\n    } else {\n      dualUploads.style.display = 'flex';\n      singleUpload.style.display = 'none';\n      pendingSingleData = null;\n    }\n  });\n\n  // Read file as data URL helper\n  function readFileAsDataURL(file, callback) {\n    if (!file || !file.type.startsWith('image/')) {\n      showNotification('Please select an image file', 'warning');\n      return;\n    }\n    const reader = new FileReader();\n    reader.onload = (e) => callback(e.target.result);\n    reader.readAsDataURL(file);\n  }\n\n  // Upload handlers\n  uploadDark?.addEventListener('change', (e) => {\n    readFileAsDataURL(e.target.files[0], (data) => {\n      pendingDarkData = data;\n      previewDark.src = data;\n      logoStatus.textContent = 'New dark logo ready to save';\n    });\n  });\n\n  uploadLight?.addEventListener('change', (e) => {\n    readFileAsDataURL(e.target.files[0], (data) => {\n      pendingLightData = data;\n      previewLight.src = data;\n      logoStatus.textContent = 'New light logo ready to save';\n    });\n  });\n\n  uploadSingle?.addEventListener('change', (e) => {\n    readFileAsDataURL(e.target.files[0], (data) => {\n      pendingSingleData = data;\n      previewDark.src = data;\n      previewLight.src = data;\n      logoStatus.textContent = 'New logo ready to save (both themes)';\n    });\n  });\n\n  // Apply logo position\n  function applyLogoPosition(pos) {\n    topRow.setAttribute('data-logo-pos', pos);\n    document.querySelectorAll('.logo-pos-btn').forEach(btn => {\n      btn.style.background = btn.dataset.pos === pos ? 'var(--accent)' : 'var(--card-bg)';\n      btn.style.color = btn.dataset.pos === pos ? 'white' : 'var(--fg)';\n    });\n  }\n\n  // Apply dashboard title\n  function applyDashboardTitle(title) {\n    currentTitle = title || DEFAULT_TITLE;\n    document.title = currentTitle;\n    const headerTitle = document.querySelector('.dashboard-title');\n    if (headerTitle) headerTitle.textContent = currentTitle;\n  }\n\n  // Load custom logo, position, and title on startup\n  async function loadCustomLogo() {\n    try {\n      const response = await fetch('/api/v1/logo');\n      if (response.ok) {\n        const data = await response.json();\n        // Apply dark/light variants\n        if (data.customLogoDark) {\n          brandLogoDark.src = data.customLogoDark;\n          previewDark.src = data.customLogoDark;\n        }\n        if (data.customLogoLight) {\n          brandLogoLight.src = data.customLogoLight;\n          previewLight.src = data.customLogoLight;\n        }\n        // Legacy single-logo fallback\n        if (!data.customLogoDark && !data.customLogoLight && data.customLogo) {\n          brandLogoDark.src = data.customLogo;\n          brandLogoLight.src = data.customLogo;\n          previewDark.src = data.customLogo;\n          previewLight.src = data.customLogo;\n        }\n        if (!data.isDefault) {\n          logoStatus.textContent = 'Using custom logo';\n        }\n        if (data.position) {\n          currentPosition = data.position;\n          applyLogoPosition(data.position);\n        }\n        if (data.dashboardTitle) {\n          applyDashboardTitle(data.dashboardTitle);\n        }\n      }\n    } catch (error) {\n      console.warn('Could not load custom logo:', error.message);\n    }\n  }\n\n  // Position button handlers\n  document.querySelectorAll('.logo-pos-btn').forEach(btn => {\n    btn.addEventListener('click', () => {\n      currentPosition = btn.dataset.pos;\n      applyLogoPosition(currentPosition);\n    });\n  });\n\n  // Open logo modal on brand click\n  document.getElementById('brand')?.addEventListener('click', () => {\n    pendingDarkData = null;\n    pendingLightData = null;\n    pendingSingleData = null;\n    if (uploadDark) uploadDark.value = '';\n    if (uploadLight) uploadLight.value = '';\n    if (uploadSingle) uploadSingle.value = '';\n    // Reset checkbox to dual mode\n    if (sameBothCheckbox) sameBothCheckbox.checked = false;\n    dualUploads.style.display = 'flex';\n    singleUpload.style.display = 'none';\n    // Reset previews to current header logos\n    previewDark.src = brandLogoDark.src;\n    previewLight.src = brandLogoLight.src;\n    const isCustom = brandLogoDark.src.includes('custom-logo') || brandLogoLight.src.includes('custom-logo');\n    logoStatus.textContent = isCustom ? 'Using custom logo' : 'Using default logos';\n    applyLogoPosition(currentPosition);\n    dashboardTitleInput.value = currentTitle;\n    logoModal.classList.add('show');\n  });\n\n  // Save logo, position, and title\n  document.getElementById('logo-save')?.addEventListener('click', async () => {\n    try {\n      const newTitle = dashboardTitleInput.value.trim() || DEFAULT_TITLE;\n      const payload = {\n        position: currentPosition,\n        dashboardTitle: newTitle\n      };\n\n      // Determine which logo data to send\n      if (sameBothCheckbox?.checked && pendingSingleData) {\n        // Single logo for both variants\n        payload.dataDark = pendingSingleData;\n        payload.dataLight = pendingSingleData;\n      } else {\n        if (pendingDarkData) payload.dataDark = pendingDarkData;\n        if (pendingLightData) payload.dataLight = pendingLightData;\n      }\n\n      const response = await secureFetch('/api/v1/logo', {\n        method: 'POST',\n        headers: { 'Content-Type': 'application/json' },\n        body: JSON.stringify(payload)\n      });\n\n      if (response.ok) {\n        const data = await response.json();\n        const t = '?t=' + Date.now();\n        if (data.pathDark) {\n          brandLogoDark.src = data.pathDark + t;\n          previewDark.src = data.pathDark + t;\n        }\n        if (data.pathLight) {\n          brandLogoLight.src = data.pathLight + t;\n          previewLight.src = data.pathLight + t;\n        }\n        applyLogoPosition(currentPosition);\n        applyDashboardTitle(newTitle);\n        logoModal.classList.remove('show');\n      } else {\n        const error = await response.json();\n        showNotification('Failed to save: ' + error.error, 'error');\n      }\n    } catch (error) {\n      showNotification('Error saving: ' + error.message, 'error');\n    }\n  });\n\n  // Reset all branding to defaults\n  document.getElementById('logo-reset')?.addEventListener('click', async () => {\n    if (!confirm('Reset all branding to DashCaddy defaults?\\n\\nThis will reset the logo, favicon, title, and position.')) return;\n\n    try {\n      const logoResponse = await secureFetch('/api/v1/logo', { method: 'DELETE' });\n      if (logoResponse.ok) {\n        brandLogoDark.src = '/assets/dashcaddy-logo-dark.png';\n        brandLogoLight.src = '/assets/dashcaddy-logo-light.png';\n        previewDark.src = '/assets/dashcaddy-logo-dark.png';\n        previewLight.src = '/assets/dashcaddy-logo-light.png';\n        logoStatus.textContent = 'Using default logos';\n        pendingDarkData = null;\n        pendingLightData = null;\n        pendingSingleData = null;\n        dashboardTitleInput.value = DEFAULT_TITLE;\n        applyDashboardTitle(DEFAULT_TITLE);\n        currentPosition = 'left';\n        applyLogoPosition('left');\n      }\n\n      const faviconResponse = await secureFetch('/api/v1/favicon', { method: 'DELETE' });\n      if (faviconResponse.ok) {\n        const faviconLink = document.querySelector('link[rel=\"icon\"]');\n        const faviconPreview = document.getElementById('favicon-preview');\n        const faviconStatus = document.getElementById('favicon-status');\n        if (faviconLink) faviconLink.href = '/assets/dashcaddy-favicon.ico?t=' + Date.now();\n        if (faviconPreview) faviconPreview.src = '/assets/dashcaddy-favicon.ico?t=' + Date.now();\n        if (faviconStatus) faviconStatus.textContent = 'Using DashCaddy favicon';\n        pendingFaviconData = null;\n      }\n    } catch (error) {\n      showNotification('Error resetting branding: ' + error.message, 'error');\n    }\n  });\n\n  wireModal(logoModal, document.getElementById('logo-cancel'));\n\n  // ===== FAVICON HANDLING =====\n  const faviconPreview = document.getElementById('favicon-preview');\n  const faviconStatus = document.getElementById('favicon-status');\n  const faviconUpload = document.getElementById('favicon-upload');\n  const faviconLink = document.querySelector('link[rel=\"icon\"]') || document.createElement('link');\n  let pendingFaviconData = null;\n\n  if (!document.querySelector('link[rel=\"icon\"]')) {\n    faviconLink.rel = 'icon';\n    faviconLink.href = '/assets/dashcaddy-favicon.ico';\n    document.head.appendChild(faviconLink);\n  }\n\n  async function loadCustomFavicon() {\n    try {\n      const response = await fetch('/api/v1/favicon');\n      if (response.ok) {\n        const data = await response.json();\n        if (data.customFavicon) {\n          faviconLink.href = data.customFavicon + '?t=' + Date.now();\n          faviconPreview.src = data.customFavicon + '?t=' + Date.now();\n          faviconStatus.textContent = 'Using custom favicon';\n        }\n      }\n    } catch (error) {\n      console.warn('Could not load custom favicon:', error.message);\n    }\n  }\n\n  faviconUpload?.addEventListener('change', (e) => {\n    const file = e.target.files[0];\n    if (!file) return;\n    if (!file.type.match(/^image\\/(png|svg\\+xml)$/)) {\n      showNotification('Please select a PNG or SVG file', 'warning');\n      faviconUpload.value = '';\n      return;\n    }\n    const reader = new FileReader();\n    reader.onload = (event) => {\n      pendingFaviconData = event.target.result;\n      faviconPreview.src = pendingFaviconData;\n      faviconStatus.textContent = 'New favicon ready to save';\n    };\n    reader.readAsDataURL(file);\n  });\n\n  // Save favicon alongside logo save\n  document.getElementById('logo-save')?.addEventListener('click', async () => {\n    if (pendingFaviconData) {\n      try {\n        const response = await secureFetch('/api/v1/favicon', {\n          method: 'POST',\n          headers: { 'Content-Type': 'application/json' },\n          body: JSON.stringify({ data: pendingFaviconData })\n        });\n        if (response.ok) {\n          const data = await response.json();\n          faviconLink.href = data.path + '?t=' + Date.now();\n          faviconPreview.src = data.path + '?t=' + Date.now();\n          faviconStatus.textContent = 'Using custom favicon';\n          pendingFaviconData = null;\n        } else {\n          const error = await response.json();\n          showNotification('Failed to save favicon: ' + error.error, 'error');\n        }\n      } catch (error) {\n        showNotification('Error saving favicon: ' + error.message, 'error');\n      }\n    }\n  });\n\n  loadCustomFavicon();\n  loadCustomLogo();\n\n  // ===== TIMEZONE SETTING =====\n  const settingsTzSelect = document.getElementById('settings-timezone');\n  if (settingsTzSelect) {\n    const observer = new MutationObserver(() => {\n      if (logoModal.classList.contains('show') && settingsTzSelect.options.length === 0) {\n        (async () => {\n          let currentTz;\n          try {\n            const res = await fetch('/api/v1/config');\n            if (res.ok) { const cfg = await res.json(); currentTz = cfg.timezone; }\n          } catch (e) { /* ignore */ }\n          window.populateTimezoneSelect(settingsTzSelect, currentTz);\n        })();\n      }\n    });\n    observer.observe(logoModal, { attributes: true, attributeFilter: ['class'] });\n\n    document.getElementById('logo-save')?.addEventListener('click', async () => {\n      const tz = settingsTzSelect.value;\n      if (!tz) return;\n      try {\n        const res = await fetch('/api/v1/config');\n        if (!res.ok) return;\n        const cfg = await res.json();\n        cfg.timezone = tz;\n        cfg.updatedAt = new Date().toISOString();\n        await secureFetch('/api/v1/config', {\n          method: 'POST',\n          headers: { 'Content-Type': 'application/json' },\n          body: JSON.stringify(cfg)\n        });\n      } catch (e) {\n        console.warn('Failed to save timezone:', e.message);\n      }\n    });\n  }\n})();\n;\n// Shared timezone utility \u2014 used by setup wizard and settings modal\n// errorHandler is declared globally in globals.js (core.js bundle); reusing it\n// here so we don't get \"redeclaration of const errorHandler\" at script scope.\n\nwindow.populateTimezoneSelect = function(selectEl, selectedTz) {\n  const timezones = Intl.supportedValuesOf('timeZone');\n  const detected = selectedTz || Intl.DateTimeFormat().resolvedOptions().timeZone || 'UTC';\n  selectEl.innerHTML = '';\n  for (const tz of timezones) {\n    const opt = document.createElement('option');\n    opt.value = tz;\n    opt.textContent = tz.replace(/_/g, ' ');\n    if (tz === detected) opt.selected = true;\n    selectEl.appendChild(opt);\n  }\n};\n\n// Setup Wizard System - Server-side config storage\n(function () {\n  let currentConfigType = 'homelab';\n  let serverConfig = null;\n\n  // Check server for existing config on page load\n  async function checkServerConfig() {\n    try {\n      const response = await fetch('/api/v1/config');\n      if (response.ok) {\n        serverConfig = await response.json();\n        if (serverConfig && serverConfig.setupComplete) {\n          // Config exists on server - don't show wizard\n          document.getElementById('setup-wizard').style.display = 'none';\n          return true;\n        }\n      }\n    } catch (error) {\n      console.warn('Could not fetch server config, checking localStorage fallback:', error.message);\n    }\n\n    // Fallback: check localStorage for backwards compatibility\n    const localSetup = safeGet('dashcaddy-setup');\n    if (localSetup) {\n      document.getElementById('setup-wizard').style.display = 'none';\n      return true;\n    }\n\n    // No config found - show wizard\n    document.getElementById('setup-wizard').style.display = 'flex';\n    return false;\n  }\n\n  // Initialize on page load\n  checkServerConfig();\n\n  // Populate timezone dropdown with auto-detection\n  const setupTzSelect = document.getElementById('setup-timezone');\n  if (setupTzSelect) window.populateTimezoneSelect(setupTzSelect);\n\n  // Step navigation\n  function showStep(stepId) {\n    document.querySelectorAll('.setup-step').forEach(step => {\n      step.style.display = 'none';\n    });\n    const targetStep = document.getElementById(stepId);\n    if (targetStep) {\n      targetStep.style.display = 'block';\n    }\n  }\n\n  // Show summary\n  function showSummary() {\n    const summaryContent = document.getElementById('setup-summary-content');\n    if (!summaryContent) return;\n\n    let html = '<div style=\"display: grid; gap: 20px;\">';\n\n    if (currentConfigType === 'homelab') {\n      const tld = document.getElementById('setup-tld')?.value?.trim() || '.home';\n      const caName = document.getElementById('setup-ca-name')?.value?.trim() || '';\n      const dnsIP = document.getElementById('setup-dns-ip')?.value?.trim() || '';\n      const dnsPort = document.getElementById('setup-dns-port')?.value?.trim() || DC.DEFAULTS.DNS_PORT;\n\n      html += `\n        <div>\n          <h3 style=\"margin: 0 0 12px; color: var(--accent);\">Home Lab Configuration</h3>\n          <div style=\"display: grid; gap: 12px; font-size: 0.95rem;\">\n            <div><strong>TLD:</strong> ${tld}</div>\n            <div><strong>Certificate Authority:</strong> ${caName}</div>\n            <div><strong>DNS Server:</strong> ${dnsIP}:${dnsPort}</div>\n            <div><strong>Example URLs:</strong> https://uptime${tld}, https://nextcloud${tld}</div>\n          </div>\n        </div>\n      `;\n    } else if (currentConfigType === 'simple') {\n      const ip = document.getElementById('setup-simple-ip')?.value?.trim() || 'localhost';\n\n      html += `\n        <div>\n          <h3 style=\"margin: 0 0 12px; color: var(--accent);\">Simple Setup</h3>\n          <div style=\"display: grid; gap: 12px; font-size: 0.95rem;\">\n            <div><strong>Access Method:</strong> IP:Port only</div>\n            <div><strong>Default IP:</strong> ${ip}</div>\n            <div><strong>SSL:</strong> None (HTTP only)</div>\n            <div><strong>Example URLs:</strong> http://${ip}:8080, http://${ip}:3000</div>\n          </div>\n        </div>\n      `;\n    } else if (currentConfigType === 'public') {\n      const domain = document.getElementById('setup-public-domain')?.value?.trim() || '';\n      const email = document.getElementById('setup-public-email')?.value?.trim() || '';\n      const routingMode = document.querySelector('input[name=\"routing-mode\"]:checked')?.value || 'subdirectory';\n      const exampleUrls = routingMode === 'subdirectory'\n        ? `https://${domain}/sonarr, https://${domain}/grafana`\n        : `https://sonarr.${domain}, https://grafana.${domain}`;\n      const routingLabel = routingMode === 'subdirectory' ? 'Subdirectory (domain.com/app)' : 'Subdomain (app.domain.com)';\n\n      html += `\n        <div>\n          <h3 style=\"margin: 0 0 12px; color: var(--accent);\">Public Server</h3>\n          <div style=\"display: grid; gap: 12px; font-size: 0.95rem;\">\n            <div><strong>Domain:</strong> ${domain}</div>\n            <div><strong>SSL:</strong> Let's Encrypt</div>\n            <div><strong>Email:</strong> ${email}</div>\n            <div><strong>Routing:</strong> ${routingLabel}</div>\n            <div><strong>Example URLs:</strong> ${exampleUrls}</div>\n          </div>\n        </div>\n      `;\n    }\n\n    // Timezone (universal across all config types)\n    const tz = document.getElementById('setup-timezone')?.value || Intl.DateTimeFormat().resolvedOptions().timeZone || 'UTC';\n    html += `\n      <div style=\"margin-top: 8px; padding-top: 12px; border-top: 1px solid var(--border);\">\n        <div style=\"font-size: 0.95rem;\"><strong>Timezone:</strong> ${tz.replace(/_/g, ' ')}</div>\n      </div>\n    `;\n\n    html += '</div>';\n    summaryContent.innerHTML = html;\n    showStep('setup-step-summary');\n  }\n\n  // Save config to server\n  async function saveConfigToServer(config) {\n    try {\n      const response = await secureFetch('/api/v1/config', {\n        method: 'POST',\n        headers: { 'Content-Type': 'application/json' },\n        body: JSON.stringify(config)\n      });\n\n      if (response.ok) {\n        await response.json();\n        return true;\n      } else {\n        errorHandler.logError('[SetupWizard] Save Config', new Error(`Server returned ${response.status}`), { function: 'saveConfigToServer' });\n        return false;\n      }\n    } catch (error) {\n      errorHandler.logError('[SetupWizard] Save Config', error, { function: 'saveConfigToServer' });\n      return false;\n    }\n  }\n\n  // Finish setup handler\n  async function finishSetup() {\n    const config = {\n      setupComplete: true,\n      configurationType: currentConfigType,\n      timestamp: new Date().toISOString(),\n      timezone: document.getElementById('setup-timezone')?.value || Intl.DateTimeFormat().resolvedOptions().timeZone || 'UTC'\n    };\n\n    if (currentConfigType === 'homelab') {\n      config.tld = document.getElementById('setup-tld')?.value?.trim() || '.home';\n      config.caName = document.getElementById('setup-ca-name')?.value?.trim() || '';\n      const selectedProvider = document.getElementById('setup-dns-provider')?.value || 'technitium';\n      config.dns = {\n        provider: selectedProvider,\n        ip: document.getElementById('setup-dns-ip')?.value?.trim() || '',\n        port: document.getElementById('setup-dns-port')?.value?.trim() || DC.DEFAULTS.DNS_PORT,\n        token: document.getElementById('setup-dns-token')?.value?.trim() || ''\n      };\n      config.defaults = {\n        dnsType: 'private',\n        sslType: 'internal',\n        targetIP: 'localhost'\n      };\n    } else if (currentConfigType === 'simple') {\n      config.defaultIP = document.getElementById('setup-simple-ip')?.value?.trim() || 'localhost';\n      config.defaults = {\n        dnsType: 'none',\n        sslType: 'none',\n        targetIP: config.defaultIP\n      };\n    } else if (currentConfigType === 'public') {\n      config.domain = document.getElementById('setup-public-domain')?.value?.trim() || '';\n      config.email = document.getElementById('setup-public-email')?.value?.trim() || '';\n      config.routingMode = document.querySelector('input[name=\"routing-mode\"]:checked')?.value || 'subdirectory';\n      config.defaults = {\n        dnsType: config.routingMode === 'subdirectory' ? 'none' : 'public',\n        sslType: 'letsencrypt',\n        targetIP: 'localhost'\n      };\n    }\n\n    // Save to server (primary) and localStorage (fallback)\n    const savedToServer = await saveConfigToServer(config);\n    safeSet('dashcaddy-config', JSON.stringify(config));\n    safeSet('dashcaddy-setup', 'completed');\n\n    // Hide wizard\n    document.getElementById('setup-wizard').style.display = 'none';\n\n    // Show success notification\n    const configName = currentConfigType === 'homelab' ? 'Professional Home Lab' :\n                      currentConfigType === 'simple' ? 'Simple Setup' : 'Public Server';\n    const saveLocation = savedToServer ? 'server (shared across all devices)' : 'locally (this browser only)';\n\n    showNotification(`Setup Complete! Configured for: ${configName}. Settings saved to: ${saveLocation}`, 'success', 5000);\n\n    // Reload page to apply configuration\n    setTimeout(() => location.reload(), 500);\n  }\n\n  // ===== Event Handlers using direct onclick for reliability =====\n\n  // Step 1: Continue button\n  const step1Next = document.getElementById('setup-step-1-next');\n  if (step1Next) {\n    step1Next.onclick = function(e) {\n      e.preventDefault();\n      const selected = document.querySelector('input[name=\"config-type\"]:checked');\n      if (selected) {\n        currentConfigType = selected.value;\n      }\n      if (currentConfigType === 'homelab') {\n        showStep('setup-step-homelab');\n      } else if (currentConfigType === 'simple') {\n        showStep('setup-step-simple');\n      } else if (currentConfigType === 'public') {\n        showStep('setup-step-public');\n      } else {\n        showStep('setup-step-homelab');\n      }\n    };\n  }\n\n  // Skip setup button\n  const skipBtn = document.getElementById('setup-skip');\n  if (skipBtn) {\n    skipBtn.onclick = async function(e) {\n      e.preventDefault();\n      if (confirm('Skip setup? You can run it later from Settings.')) {\n        // Save skip status to server\n        await saveConfigToServer({ setupComplete: true, skipped: true, timestamp: new Date().toISOString() });\n        safeSet('dashcaddy-setup', 'skipped');\n        document.getElementById('setup-wizard').style.display = 'none';\n      }\n    };\n  }\n\n  // Home Lab: TLD Preview\n  const tldInput = document.getElementById('setup-tld');\n  if (tldInput) {\n    tldInput.oninput = function(e) {\n      const tld = e.target.value || '.home';\n      const preview1 = document.getElementById('tld-preview');\n      const preview2 = document.getElementById('tld-preview-2');\n      if (preview1) preview1.textContent = tld;\n      if (preview2) preview2.textContent = tld;\n    };\n  }\n\n  // Home Lab navigation\n  const homelabBack = document.getElementById('setup-homelab-back');\n  if (homelabBack) {\n    homelabBack.onclick = function(e) {\n      e.preventDefault();\n      showStep('setup-step-1');\n    };\n  }\n\n  const homelabNext = document.getElementById('setup-homelab-next');\n  if (homelabNext) {\n    homelabNext.onclick = function(e) {\n      e.preventDefault();\n      const tld = document.getElementById('setup-tld')?.value?.trim() || '';\n      const caName = document.getElementById('setup-ca-name')?.value?.trim() || '';\n      const dnsIP = document.getElementById('setup-dns-ip')?.value?.trim() || '';\n\n      if (!tld || !tld.startsWith('.')) {\n        showNotification('Please enter a valid TLD starting with a dot (e.g., .home)', 'warning');\n        return;\n      }\n      if (!caName) {\n        showNotification('Please enter a Certificate Authority name', 'warning');\n        return;\n      }\n      if (!dnsIP) {\n        showNotification('Please enter your DNS server IP address', 'warning');\n        return;\n      }\n      showSummary();\n    };\n  }\n\n  // Simple navigation\n  const simpleBack = document.getElementById('setup-simple-back');\n  if (simpleBack) {\n    simpleBack.onclick = function(e) {\n      e.preventDefault();\n      showStep('setup-step-1');\n    };\n  }\n\n  const simpleNext = document.getElementById('setup-simple-next');\n  if (simpleNext) {\n    simpleNext.onclick = function(e) {\n      e.preventDefault();\n      showSummary();\n    };\n  }\n\n  // Public routing mode toggle \u2014 update requirement text\n  document.querySelectorAll('input[name=\"routing-mode\"]').forEach(function(radio) {\n    radio.onchange = function() {\n      var note = document.getElementById('dns-requirement-note');\n      if (note) {\n        note.textContent = this.value === 'subdirectory'\n          ? 'Only one DNS record needed (for the main domain)'\n          : 'You\\'ll need to configure DNS manually for each subdomain';\n      }\n    };\n  });\n\n  // Public navigation\n  const publicBack = document.getElementById('setup-public-back');\n  if (publicBack) {\n    publicBack.onclick = function(e) {\n      e.preventDefault();\n      showStep('setup-step-1');\n    };\n  }\n\n  const publicNext = document.getElementById('setup-public-next');\n  if (publicNext) {\n    publicNext.onclick = function(e) {\n      e.preventDefault();\n      const domain = document.getElementById('setup-public-domain')?.value?.trim() || '';\n      const email = document.getElementById('setup-public-email')?.value?.trim() || '';\n\n      if (!domain) {\n        showNotification('Please enter your domain name', 'warning');\n        return;\n      }\n      if (!email || !email.includes('@')) {\n        showNotification('Please enter a valid email address', 'warning');\n        return;\n      }\n      showSummary();\n    };\n  }\n\n  // Summary navigation\n  const summaryBack = document.getElementById('setup-summary-back');\n  if (summaryBack) {\n    summaryBack.onclick = function(e) {\n      e.preventDefault();\n      if (currentConfigType === 'homelab') {\n        showStep('setup-step-homelab');\n      } else if (currentConfigType === 'simple') {\n        showStep('setup-step-simple');\n      } else if (currentConfigType === 'public') {\n        showStep('setup-step-public');\n      }\n    };\n  }\n\n  // Summary \"Continue \u2192\" \u2014 advance to the disk-safety warning step\n  const summaryNext = document.getElementById('setup-summary-next');\n  if (summaryNext) {\n    summaryNext.onclick = function(e) {\n      e.preventDefault();\n      showStep('setup-step-disk-safety');\n    };\n  }\n\n  // Disk-safety step navigation\n  const diskSafetyBack = document.getElementById('setup-disk-safety-back');\n  if (diskSafetyBack) {\n    diskSafetyBack.onclick = function(e) {\n      e.preventDefault();\n      showStep('setup-step-summary');\n    };\n  }\n\n  // Finish setup button (now on the disk-safety step)\n  const finishBtn = document.getElementById('setup-disk-safety-finish');\n  if (finishBtn) {\n    finishBtn.onclick = function(e) {\n      e.preventDefault();\n      finishSetup();\n    };\n  }\n\n  // Expose function to get global config (from server or localStorage)\n  window.getGlobalConfig = async function() {\n    // Try server first\n    try {\n      const response = await fetch('/api/v1/config');\n      if (response.ok) {\n        const config = await response.json();\n        if (config && config.setupComplete) {\n          return config;\n        }\n      }\n    } catch (e) {\n      console.warn('Could not fetch config from server');\n    }\n\n    // Fallback to localStorage\n    const configStr = safeGet('dashcaddy-config');\n    if (configStr) {\n      return JSON.parse(configStr);\n    }\n\n    // Return default config if not set\n    return {\n      setupComplete: false,\n      configurationType: 'homelab',\n      tld: '.home',\n      caName: '',\n      defaults: {\n        dnsType: 'private',\n        sslType: 'internal',\n        targetIP: 'localhost'\n      }\n    };\n  };\n\n  // Expose reset function for settings\n  window.resetSetupWizard = async function() {\n    if (confirm('Reset DashCaddy configuration? This will show the setup wizard again.')) {\n      try {\n        await secureFetch('/api/v1/config', { method: 'DELETE' });\n      } catch (e) {\n        console.warn('Could not delete server config');\n      }\n      safeRemove('dashcaddy-setup');\n      safeRemove('dashcaddy-config');\n      location.reload();\n    }\n  };\n})();\n;\n// App Selector System\n(function () {\n  const errorHandler = new ErrorHandler();\n  injectModal('app-selector-modal', `<div id=\"app-selector-modal\" class=\"weather-modal\">\n    <div class=\"app-selector-content\">\n      <h2 style=\"margin: 0 0 24px; color: var(--fg); text-align: center;\">Choose an App</h2>\n      <div id=\"app-selector-grid\" class=\"app-selector-grid\"></div>\n      <div style=\"text-align: center; margin-top: 24px;\">\n        <button id=\"app-selector-cancel\">Cancel</button>\n      </div>\n    </div>\n  </div>`);\n\n  injectModal('app-deploy-modal', `<div id=\"app-deploy-modal\" class=\"weather-modal\">\n    <div class=\"weather-modal-content\" style=\"min-width: 600px; max-width: 700px;\">\n      <h3 id=\"app-deploy-title\">Deploy Application</h3>\n\n      <div style=\"display: grid; grid-template-columns: 1fr; gap: 16px; margin-top: 16px;\">\n        <!-- Subdomain/Domain -->\n        <div>\n          <label for=\"deploy-subdomain\" class=\"form-label-accent-sm\">\n            \uD83C\uDF10 Subdomain or Domain\n          </label>\n          <input type=\"text\" id=\"deploy-subdomain\" placeholder=\"uptime\"\n                 style=\"width: 100%; padding: 10px; background: var(--card-bg); color: var(--fg); border: 1px solid var(--border); border-radius: 6px; font-size: 0.95rem;\" />\n          <div class=\"form-hint-sm\">\n            Your app will be available at: <span id=\"deploy-url-preview\" style=\"color: var(--accent); font-weight: 500;\">uptime.home</span>\n          </div>\n          <div id=\"subpath-compat-warning\" style=\"display: none; padding: 8px 12px; border-radius: 6px; background: color-mix(in srgb, #ff9800 10%, var(--card-bg)); border: 1px solid color-mix(in srgb, #ff9800 30%, transparent); margin-top: 8px; font-size: 0.85rem;\"></div>\n        </div>\n\n        <!-- DNS Configuration -->\n        <div>\n          <label class=\"form-label-accent\">\n            \uD83D\uDDC2\uFE0F DNS Configuration\n          </label>\n          <div class=\"flex-col-gap\">\n            <label class=\"radio-option\">\n              <input type=\"radio\" name=\"dns-type\" value=\"private\" checked style=\"margin-right: 10px;\" />\n              <div>\n                <div class=\"fw-500\">Private DNS (Technitium)</div>\n                <div class=\"text-hint\">Use your local DNS server with custom TLD (.sami, .home, etc.)</div>\n              </div>\n            </label>\n            <label class=\"radio-option\">\n              <input type=\"radio\" name=\"dns-type\" value=\"public\" style=\"margin-right: 10px;\" />\n              <div>\n                <div class=\"fw-500\">Public DNS</div>\n                <div class=\"text-hint\">Use a real domain (example.com) - requires DNS provider setup</div>\n              </div>\n            </label>\n            <label class=\"radio-option\">\n              <input type=\"radio\" name=\"dns-type\" value=\"none\" style=\"margin-right: 10px;\" />\n              <div>\n                <div class=\"fw-500\">No DNS (IP:Port only)</div>\n                <div class=\"text-hint\">Access via IP address and port - no domain setup</div>\n              </div>\n            </label>\n          </div>\n        </div>\n\n        <!-- SSL Configuration -->\n        <div>\n          <label class=\"form-label-accent\">\n            \uD83D\uDD12 SSL/TLS Certificate\n          </label>\n          <div class=\"flex-col-gap\">\n            <label class=\"radio-option\">\n              <input type=\"radio\" name=\"ssl-type\" value=\"internal\" checked style=\"margin-right: 10px;\" />\n              <div>\n                <div class=\"fw-500\">Internal CA</div>\n                <div class=\"text-hint\">Use Caddy's internal certificate authority (self-signed)</div>\n              </div>\n            </label>\n            <label class=\"radio-option\">\n              <input type=\"radio\" name=\"ssl-type\" value=\"letsencrypt\" style=\"margin-right: 10px;\" />\n              <div>\n                <div class=\"fw-500\">Let's Encrypt</div>\n                <div class=\"text-hint\">Free public SSL certificate (requires public domain)</div>\n              </div>\n            </label>\n            <label class=\"radio-option\">\n              <input type=\"radio\" name=\"ssl-type\" value=\"none\" style=\"margin-right: 10px;\" />\n              <div>\n                <div class=\"fw-500\">No SSL (HTTP only)</div>\n                <div class=\"text-hint\">\u26A0\uFE0F Not recommended - traffic will be unencrypted</div>\n              </div>\n            </label>\n          </div>\n        </div>\n\n        <!-- Media Library Path (shown for media apps) -->\n        <div id=\"media-path-section\" style=\"display: none;\">\n          <label class=\"form-label-accent\">\n            \uD83D\uDCC1 Media Library Location\n          </label>\n          <div style=\"display: flex; flex-direction: column; gap: 10px;\">\n            <!-- Detected mounts from existing media servers -->\n            <div id=\"detected-mounts-container\" style=\"display: none;\">\n              <div style=\"font-size: 0.85rem; color: var(--success); margin-bottom: 6px;\">\n                \u2713 Detected from existing media servers:\n              </div>\n              <div id=\"detected-mounts-list\" style=\"display: flex; gap: 8px; flex-wrap: wrap;\"></div>\n            </div>\n\n            <!-- Path input with browse button -->\n            <div class=\"flex-row-gap\">\n              <input type=\"text\" id=\"deploy-media-path\" placeholder=\"/media/Movies, /media/TVShows\"\n                     class=\"input-flex\" style=\"font-size: 0.95rem;\" />\n              <button type=\"button\" id=\"browse-media-btn\" style=\"padding: 10px 16px; background: var(--accent); color: white; border: none; border-radius: 6px; cursor: pointer; font-weight: 500; white-space: nowrap;\">\n                \uD83D\uDCC2 Browse\n              </button>\n            </div>\n\n            <div id=\"media-path-description\" class=\"text-hint\">\n              Select folders from existing servers, browse, or type paths manually. Separate multiple with commas.\n            </div>\n\n            <!-- Selected paths display -->\n            <div id=\"selected-media-paths\" style=\"display: none; flex-wrap: wrap; gap: 6px;\"></div>\n          </div>\n        </div>\n\n        <!-- Plex Claim Token (shown only for Plex deployments) -->\n        <div id=\"plex-claim-section\" style=\"display: none;\">\n          <label class=\"form-label-accent\">\n            \uD83D\uDD11 Plex Claim Token\n          </label>\n          <div class=\"flex-row-gap\">\n            <input type=\"text\" id=\"deploy-plex-claim\" placeholder=\"claim-xxxxxxxxxxxxxxxxxxxx\"\n                   class=\"input-flex\" style=\"font-size: 0.95rem;\" />\n            <a href=\"https://plex.tv/claim\" target=\"_blank\" rel=\"noopener noreferrer\"\n               style=\"padding: 10px 16px; background: #e5a00d; color: #000; border: none; border-radius: 6px; cursor: pointer; font-weight: 500; white-space: nowrap; text-decoration: none; display: flex; align-items: center;\">\n              Get Token\n            </a>\n          </div>\n          <div style=\"font-size: 0.8rem; color: #e5a00d; margin-top: 4px;\">\n            Token expires in 4 minutes! Get it right before clicking Deploy. Leave empty to configure Plex manually later.\n          </div>\n        </div>\n\n        <!-- Tailscale Security -->\n        <div id=\"tailscale-section\">\n          <label class=\"form-label-accent\">\n            \uD83D\uDD10 Tailscale Security\n          </label>\n          <div class=\"flex-col-gap\">\n            <label class=\"radio-option\">\n              <input type=\"checkbox\" id=\"deploy-tailscale-only\" style=\"margin-right: 10px; width: 18px; height: 18px;\" />\n              <div>\n                <div class=\"fw-500\">Tailscale-Only Access</div>\n                <div class=\"text-hint\">Restrict this service to Tailscale users only (100.x.x.x IPs)</div>\n              </div>\n            </label>\n            <div id=\"tailscale-status\" style=\"padding: 8px 12px; background: var(--card-bg); border-radius: 6px; font-size: 0.85rem;\">\n              <span style=\"color: var(--muted);\">Checking Tailscale status...</span>\n            </div>\n          </div>\n        </div>\n\n        <!-- Advanced Options (Collapsible) -->\n        <details>\n          <summary style=\"cursor: pointer; color: var(--accent); font-weight: 500; margin-bottom: 8px;\">\u2699\uFE0F Advanced Options</summary>\n          <div style=\"margin-top: 12px; display: grid; gap: 12px;\">\n            <div>\n              <label for=\"deploy-port\" style=\"display: block; margin-bottom: 6px;\">Custom Port (optional)</label>\n              <input type=\"number\" id=\"deploy-port\" placeholder=\"Leave empty for default\"\n                     class=\"form-input-card\" />\n            </div>\n            <div>\n              <label for=\"deploy-ip\" style=\"display: block; margin-bottom: 6px;\">Target IP Address</label>\n              <input type=\"text\" id=\"deploy-ip\" value=\"localhost\"\n                     class=\"form-input-card\" />\n              <div class=\"form-hint-sm\">\n                Use 'localhost' for same-host containers, or specific IP for remote services\n              </div>\n            </div>\n            <div id=\"volume-mounts-section\" style=\"display: none;\">\n              <label class=\"form-label-accent-sm\">\uD83D\uDCC2 Volume Mounts</label>\n              <div style=\"font-size: 0.8rem; color: var(--muted); margin-bottom: 8px;\">\n                Customize where container data is stored on the host. Media volumes are configured above.\n              </div>\n              <div id=\"volume-mounts-list\" style=\"display: grid; gap: 8px;\"></div>\n            </div>\n            <div style=\"margin-top: 12px;\">\n              <label class=\"form-label-accent-sm\">\u2699\uFE0F Resource Limits</label>\n              <div style=\"font-size: 0.8rem; color: var(--muted); margin-bottom: 8px;\">\n                Optional CPU and memory constraints. Leave at 0 for unlimited.\n              </div>\n              <div style=\"display: grid; grid-template-columns: 1fr 1fr; gap: 10px;\">\n                <div>\n                  <label for=\"deploy-cpu-limit\" style=\"display: block; font-size: 0.78rem; color: var(--muted); margin-bottom: 4px;\">CPU Cores</label>\n                  <input type=\"number\" id=\"deploy-cpu-limit\" value=\"0\" min=\"0\" max=\"64\" step=\"0.25\" class=\"form-input-card\" style=\"width: 100%;\" placeholder=\"0 = unlimited\" />\n                </div>\n                <div>\n                  <label for=\"deploy-memory-limit\" style=\"display: block; font-size: 0.78rem; color: var(--muted); margin-bottom: 4px;\">Memory (MB)</label>\n                  <input type=\"number\" id=\"deploy-memory-limit\" value=\"0\" min=\"0\" max=\"131072\" step=\"64\" class=\"form-input-card\" style=\"width: 100%;\" placeholder=\"0 = unlimited\" />\n                </div>\n              </div>\n            </div>\n          </div>\n        </details>\n      </div>\n\n      <div class=\"weather-modal-buttons\" style=\"margin-top: 24px;\">\n        <button id=\"app-deploy-cancel\">Cancel</button>\n        <button id=\"app-deploy-confirm\" class=\"btn-accent\">\n          \uD83D\uDE80 Deploy\n        </button>\n      </div>\n    </div>\n  </div>`);\n\n  const APPS_KEY = 'custom-apps';\n\n  // Cache for API templates\n  let apiTemplates = null;\n  let apiCategories = null;\n\n  const modal = document.getElementById('app-selector-modal');\n  const grid = document.getElementById('app-selector-grid');\n\n  // Fetch app templates from API\n  async function fetchAppTemplates() {\n    try {\n      const response = await fetch('/api/v1/apps/templates');\n      const data = await response.json();\n      if (data.success) {\n        apiTemplates = data.templates;\n        apiCategories = data.categories;\n        return true;\n      }\n    } catch (e) {\n      errorHandler.logError('[AppSelector] Fetch Templates', e, { function: 'fetchApiTemplates' });\n    }\n    return false;\n  }\n\n  // Check port availability\n  async function checkPortAvailability(port) {\n    try {\n      const response = await fetch(`/api/v1/apps/ports/${port}/check`);\n      const data = await response.json();\n      return data;\n    } catch (e) {\n      errorHandler.logError('[AppSelector] Check Port', e, { function: 'checkPortAvailability' });\n      return { available: true }; // Assume available on error\n    }\n  }\n\n  // Get suggested available port\n  async function getSuggestedPort(basePort) {\n    try {\n      const response = await fetch(`/api/v1/apps/ports/${basePort}/suggest`);\n      const data = await response.json();\n      if (data.success) {\n        return data.suggestedPort;\n      }\n    } catch (e) {\n      errorHandler.logError('[AppSelector] Get Suggested Port', e, { function: 'getSuggestedPort' });\n    }\n    return basePort;\n  }\n\n  // Build app selector grid from API templates\n  async function buildAppSelector() {\n    grid.innerHTML = '<div style=\"text-align: center; padding: 40px; color: var(--muted);\">Loading app templates...</div>';\n\n    // Fetch templates if not cached\n    if (!apiTemplates) {\n      const success = await fetchAppTemplates();\n      if (!success) {\n        grid.innerHTML = '<div style=\"text-align: center; padding: 40px; color: var(--error);\">Failed to load app templates. Please try again.</div>';\n        return;\n      }\n    }\n\n    grid.innerHTML = '';\n\n    // Group templates by category\n    const byCategory = {};\n    for (const [appId, template] of Object.entries(apiTemplates)) {\n      const category = template.category || 'Other';\n      if (!byCategory[category]) {\n        byCategory[category] = [];\n      }\n      byCategory[category].push({ id: appId, ...template });\n    }\n\n    // Sort categories by the order in apiCategories if available\n    const categoryOrder = apiCategories ? Object.keys(apiCategories) : Object.keys(byCategory).sort();\n\n    for (const category of categoryOrder) {\n      const apps = byCategory[category];\n      if (!apps || apps.length === 0) continue;\n\n      // Sort apps by popularity (descending)\n      apps.sort((a, b) => (b.popularity || 0) - (a.popularity || 0));\n\n      // Category header with icon and color from API\n      const header = document.createElement('div');\n      header.className = 'app-category-header';\n      const categoryInfo = apiCategories?.[category] || {};\n      header.innerHTML = `${escapeHtml(categoryInfo.icon || '')} ${escapeHtml(category)}`;\n      if (categoryInfo.color) {\n        header.style.borderBottomColor = categoryInfo.color;\n      }\n      grid.appendChild(header);\n\n      // App options\n      apps.forEach(app => {\n        const option = document.createElement('div');\n        option.className = 'app-option';\n\n        // Widget enabled badge\n        const isWidget = app.isDashboardWidget;\n        const widgetEnabled = isWidget && safeGet('widget-' + app.id + '-enabled') !== 'false';\n        const widgetBadge = isWidget\n          ? `<div style=\"font-size: 0.65rem; padding: 2px 6px; border-radius: 4px; margin-top: 4px; background: ${widgetEnabled ? '#2ecc7130' : '#e74c3c30'}; color: ${widgetEnabled ? '#2ecc71' : '#e74c3c'}; font-weight: 600;\">${widgetEnabled ? 'ON' : 'OFF'}</div>`\n          : '';\n\n        // Show difficulty badge (non-widgets only)\n        const difficultyBadge = !isWidget && app.difficulty ?\n          `<div style=\"font-size: 0.65rem; padding: 2px 6px; border-radius: 4px; margin-top: 4px; background: ${\n            app.difficulty === 'Easy' ? '#2ecc71' :\n            app.difficulty === 'Intermediate' ? '#f39c12' : '#e74c3c'\n          }20; color: ${\n            app.difficulty === 'Easy' ? '#2ecc71' :\n            app.difficulty === 'Intermediate' ? '#f39c12' : '#e74c3c'\n          };\">${escapeHtml(app.difficulty)}</div>` : '';\n\n        option.innerHTML = `\n          <div class=\"app-option-icon\">${escapeHtml(app.icon || '\uD83D\uDCE6')}</div>\n          <div class=\"app-option-name\">${escapeHtml(app.name)}</div>\n          <div class=\"app-option-desc\">${escapeHtml(app.description || '')}</div>\n          ${widgetBadge}${difficultyBadge}\n        `;\n\n        if (isWidget) {\n          option.onclick = () => toggleDashboardWidget(app, option);\n        } else {\n          option.onclick = () => showDeployConfig(app);\n        }\n        grid.appendChild(option);\n      });\n    }\n\n    // Render recipe cards at the end of the grid\n    if (window.renderRecipeCards) {\n      await window.renderRecipeCards(grid);\n    }\n  }\n\n  // Toggle a dashboard widget on/off\n  function toggleDashboardWidget(app, optionEl) {\n    const key = 'widget-' + app.id + '-enabled';\n    const currentlyEnabled = safeGet(key) !== 'false';\n    const newState = !currentlyEnabled;\n    safeSet(key, String(newState));\n\n    // Update visibility immediately\n    const selector = app.widgetSelector;\n    if (selector) {\n      const el = document.querySelector(selector);\n      if (el) el.style.display = newState ? '' : 'none';\n    }\n\n    // Update the badge in the app selector card\n    const badge = optionEl.querySelector('div[style*=\"border-radius: 4px\"]');\n    if (badge) {\n      badge.textContent = newState ? 'ON' : 'OFF';\n      badge.style.background = newState ? '#2ecc7130' : '#e74c3c30';\n      badge.style.color = newState ? '#2ecc71' : '#e74c3c';\n    }\n\n    showNotification(`${app.name} widget ${newState ? 'enabled' : 'disabled'}`, 'success', 2000);\n  }\n\n  // Show deployment configuration modal\n  async function showDeployConfig(appTemplate) {\n    const deployModal = document.getElementById('app-deploy-modal');\n    const title = document.getElementById('app-deploy-title');\n    const subdomainInput = document.getElementById('deploy-subdomain');\n    const urlPreview = document.getElementById('deploy-url-preview');\n    const ipInput = document.getElementById('deploy-ip');\n    const portInput = document.getElementById('deploy-port');\n    const tailscaleCheckbox = document.getElementById('deploy-tailscale-only');\n    const tailscaleStatus = document.getElementById('tailscale-status');\n\n    // Check for existing container with same image\n    try {\n      const checkResponse = await secureFetch('/api/v1/apps/check-existing', {\n        method: 'POST',\n        headers: { 'Content-Type': 'application/json' },\n        body: JSON.stringify({ appId: appTemplate.id })\n      });\n      const checkResult = await checkResponse.json();\n\n      if (checkResult.success && checkResult.exists) {\n        const container = checkResult.container;\n        const useExisting = confirm(\n          `Found existing ${appTemplate.name} container:\\n\\n` +\n          `Container: ${container.name}\\n` +\n          `Status: ${container.status}\\n` +\n          `Port: ${container.primaryPort || 'N/A'}\\n\\n` +\n          `Would you like to use this existing container?\\n\\n` +\n          `Click OK to configure DNS/Caddy for the existing container.\\n` +\n          `Click Cancel to deploy a new container.`\n        );\n\n        if (useExisting) {\n          // Store existing container info for deployment\n          appTemplate._useExisting = true;\n          appTemplate._existingContainer = container;\n        }\n      }\n    } catch (e) {\n      // Ignore container check errors\n    }\n\n    // Set title with app info\n    title.textContent = `Deploy ${appTemplate.name}`;\n\n    // Pre-fill subdomain from template or app ID\n    const defaultSubdomain = appTemplate.subdomain || appTemplate.id.replace(/-/g, '');\n    subdomainInput.value = defaultSubdomain;\n\n    // Show subpath compatibility warning in subdirectory mode\n    const subpathWarning = document.getElementById('subpath-compat-warning');\n    if (subpathWarning) {\n      if (SITE.routingMode === 'subdirectory') {\n        const support = appTemplate.subpathSupport || 'strip';\n        if (support === 'none') {\n          subpathWarning.style.display = 'block';\n          subpathWarning.innerHTML = '<span style=\"color: #ff9800;\">&#9888; <strong>' + appTemplate.name + '</strong> does not support subdirectory mode. It may not work correctly at a subpath.</span>';\n        } else if (support === 'strip') {\n          subpathWarning.style.display = 'block';\n          subpathWarning.innerHTML = '<span style=\"color: var(--muted);\">&#9432; ' + appTemplate.name + ' has unverified subdirectory support. It may require additional configuration.</span>';\n        } else {\n          subpathWarning.style.display = 'none';\n        }\n      } else {\n        subpathWarning.style.display = 'none';\n      }\n    }\n\n    // Pre-select DNS/SSL from site config (set during setup wizard)\n    const cfgDnsType = SITE.defaults.dnsType || (SITE.configurationType === 'public' ? 'public' : 'private');\n    const cfgSslType = SITE.defaults.sslType || (SITE.configurationType === 'public' ? 'letsencrypt' : 'internal');\n    const dnsRadio = document.querySelector(`input[name=\"dns-type\"][value=\"${cfgDnsType}\"]`);\n    const sslRadio = document.querySelector(`input[name=\"ssl-type\"][value=\"${cfgSslType}\"]`);\n    if (dnsRadio) dnsRadio.checked = true;\n    else document.querySelector('input[name=\"dns-type\"][value=\"private\"]').checked = true;\n    if (sslRadio) sslRadio.checked = true;\n    else document.querySelector('input[name=\"ssl-type\"][value=\"internal\"]').checked = true;\n    ipInput.value = SITE.defaults.targetIP || 'localhost';\n    tailscaleCheckbox.checked = false;\n\n    // Move DNS/SSL into Advanced section when already configured\n    const dnsSection = document.querySelector('#app-deploy-modal .flex-col-gap')?.closest('div');\n    const advancedDetails = document.querySelector('#app-deploy-modal details');\n    const advancedContent = advancedDetails?.querySelector('div');\n    if (advancedDetails && advancedContent && (SITE.configurationType === 'public' || SITE.configurationType === 'homelab')) {\n      // Move DNS and SSL sections inside Advanced\n      const dnsSectionEl = document.querySelectorAll('#app-deploy-modal input[name=\"dns-type\"]')[0]?.closest('div.flex-col-gap')?.parentElement;\n      const sslSectionEl = document.querySelectorAll('#app-deploy-modal input[name=\"ssl-type\"]')[0]?.closest('div.flex-col-gap')?.parentElement;\n      if (dnsSectionEl && !dnsSectionEl.dataset.moved) {\n        advancedContent.appendChild(dnsSectionEl);\n        dnsSectionEl.dataset.moved = '1';\n      }\n      if (sslSectionEl && !sslSectionEl.dataset.moved) {\n        advancedContent.appendChild(sslSectionEl);\n        sslSectionEl.dataset.moved = '1';\n      }\n    }\n\n    // Handle media path section for media apps\n    const mediaPathSection = document.getElementById('media-path-section');\n    const mediaPathInput = document.getElementById('deploy-media-path');\n    const mediaPathDescription = document.getElementById('media-path-description');\n\n    if (appTemplate.mediaMount) {\n      mediaPathSection.style.display = 'block';\n      mediaPathInput.value = '';\n      mediaPathInput.placeholder = '/media/Movies, /media/TVShows or click Browse';\n\n      // Fetch detected mounts from existing media servers\n      const detectedMountsContainer = document.getElementById('detected-mounts-container');\n      const detectedMountsList = document.getElementById('detected-mounts-list');\n\n      try {\n        const mountsResponse = await fetch('/api/v1/media/detected-mounts');\n        const mountsResult = await mountsResponse.json();\n\n        if (mountsResult.success && mountsResult.mounts.length > 0) {\n          detectedMountsContainer.style.display = 'block';\n          detectedMountsList.innerHTML = '';\n\n          // Auto-fill media path with all detected mounts\n          const autoPaths = [...new Set(mountsResult.mounts.map(m => m.hostPath))];\n          mediaPathInput.value = autoPaths.join(', ');\n\n          mountsResult.mounts.forEach(mount => {\n            const btn = document.createElement('button');\n            btn.type = 'button';\n            const isSelected = autoPaths.includes(mount.hostPath);\n            btn.style.cssText = `padding: 8px 14px; font-size: 0.85rem; background: color-mix(in srgb, var(--success) ${isSelected ? '40%' : '15%'}, var(--card-bg)); border: 1px solid var(--success); border-radius: 6px; cursor: pointer; color: var(--fg);`;\n            btn.innerHTML = `<span style=\"font-weight: 500;\">${escapeHtml(mount.folderName)}</span><br><span style=\"font-size: 0.7rem; color: var(--muted);\">from ${escapeHtml(mount.sourceImage)}</span>`;\n            btn.title = `${mount.hostPath} (from ${mount.sourceContainer})`;\n            btn.onclick = () => {\n              const currentPaths = mediaPathInput.value.split(',').map(p => p.trim()).filter(p => p);\n              const idx = currentPaths.indexOf(mount.hostPath);\n              if (idx >= 0) {\n                currentPaths.splice(idx, 1);\n                btn.style.background = 'color-mix(in srgb, var(--success) 15%, var(--card-bg))';\n              } else {\n                currentPaths.push(mount.hostPath);\n                btn.style.background = 'color-mix(in srgb, var(--success) 40%, var(--card-bg))';\n              }\n              mediaPathInput.value = currentPaths.join(', ');\n            };\n            detectedMountsList.appendChild(btn);\n          });\n        } else {\n          detectedMountsContainer.style.display = 'none';\n        }\n      } catch (e) {\n        detectedMountsContainer.style.display = 'none';\n      }\n\n      // Set up browse button\n      document.getElementById('browse-media-btn').onclick = () => {\n        openFolderBrowser(mediaPathInput);\n      };\n    } else {\n      mediaPathSection.style.display = 'none';\n      mediaPathInput.value = '';\n      document.getElementById('detected-mounts-container').style.display = 'none';\n    }\n\n    // Show Plex claim token section for Plex deployments\n    const plexClaimSection = document.getElementById('plex-claim-section');\n    if (plexClaimSection) {\n      if (appTemplate.id === 'plex' || appTemplate.claimToken) {\n        plexClaimSection.style.display = 'block';\n        document.getElementById('deploy-plex-claim').value = '';\n      } else {\n        plexClaimSection.style.display = 'none';\n      }\n    }\n\n    // Populate volume mounts in Advanced Options\n    const volumeSection = document.getElementById('volume-mounts-section');\n    const volumeList = document.getElementById('volume-mounts-list');\n    volumeList.innerHTML = '';\n\n    if (appTemplate.docker?.volumes?.length) {\n      const mediaContainerPath = appTemplate.mediaMount?.containerPath;\n      const nonMediaVolumes = appTemplate.docker.volumes.filter(v => !v.includes('{{MEDIA_PATH}}') && !(mediaContainerPath && v.endsWith(':' + mediaContainerPath)));\n\n      if (nonMediaVolumes.length > 0) {\n        volumeSection.style.display = 'block';\n        nonMediaVolumes.forEach((vol, i) => {\n          const [hostDefault, containerPath] = vol.split(':');\n          const row = document.createElement('div');\n          row.style.cssText = 'display: flex; gap: 6px; align-items: center;';\n          row.innerHTML = `\n            <input type=\"text\" class=\"vol-host-path\" data-container-path=\"${containerPath}\" value=\"${hostDefault}\"\n                   style=\"flex: 1; padding: 8px; background: var(--card-bg); color: var(--fg); border: 1px solid var(--border); border-radius: 6px; font-size: 0.85rem;\" />\n            <span style=\"color: var(--muted); font-size: 0.85rem; white-space: nowrap;\">\u2192 ${containerPath}</span>\n            <button type=\"button\" class=\"vol-browse-btn\" style=\"padding: 8px 10px; background: var(--accent); color: white; border: none; border-radius: 6px; cursor: pointer; font-size: 0.8rem;\">\uD83D\uDCC2</button>\n          `;\n          volumeList.appendChild(row);\n          row.querySelector('.vol-browse-btn').onclick = () => {\n            const input = row.querySelector('.vol-host-path');\n            openFolderBrowser(input);\n          };\n        });\n      } else {\n        volumeSection.style.display = 'none';\n      }\n    } else {\n      volumeSection.style.display = 'none';\n    }\n\n    // Set default port from template and check availability\n    const defaultPort = appTemplate.defaultPort || 8080;\n    portInput.value = '';\n    portInput.placeholder = `Default: ${defaultPort}`;\n\n    // Add port status element if not exists\n    let portStatus = document.getElementById('deploy-port-status');\n    if (!portStatus) {\n      portStatus = document.createElement('div');\n      portStatus.id = 'deploy-port-status';\n      portStatus.style.cssText = 'font-size: 0.8rem; margin-top: 4px;';\n      portInput.parentNode.appendChild(portStatus);\n    }\n\n    // Check default port availability\n    async function checkAndUpdatePortStatus() {\n      const portToCheck = portInput.value || defaultPort;\n      portStatus.innerHTML = '<span style=\"color: var(--muted);\">Checking port...</span>';\n\n      const result = await checkPortAvailability(portToCheck);\n      if (result.available) {\n        portStatus.innerHTML = `<span style=\"color: #4caf50;\">Port ${escapeHtml(String(portToCheck))} is available</span>`;\n      } else {\n        const suggestedPort = await getSuggestedPort(defaultPort);\n        portStatus.innerHTML = `\n          <span style=\"color: #e74c3c;\">Port ${escapeHtml(portToCheck)} in use by ${escapeHtml(result.conflict?.usedBy || 'unknown')}</span>\n        `;\n        const useBtn = document.createElement('button');\n        useBtn.type = 'button';\n        useBtn.textContent = `Use ${suggestedPort}`;\n        useBtn.style.cssText = 'margin-left: 8px; padding: 2px 8px; font-size: 0.75rem; cursor: pointer;';\n        useBtn.onclick = () => {\n          document.getElementById('deploy-port').value = suggestedPort;\n          portStatus.innerHTML = `<span style=\"color: #4caf50;\">Using suggested port ${escapeHtml(String(suggestedPort))}</span>`;\n        };\n        portStatus.appendChild(useBtn);\n      }\n    }\n\n    // Check port on input change (debounced)\n    let portCheckTimeout;\n    portInput.oninput = function() {\n      clearTimeout(portCheckTimeout);\n      portCheckTimeout = setTimeout(checkAndUpdatePortStatus, 500);\n    };\n\n    // Initial port check\n    checkAndUpdatePortStatus();\n\n    // Fetch Tailscale status\n    try {\n      const response = await fetch('/api/v1/tailscale/status');\n      const data = await response.json();\n      if (data.success && data.installed && data.connected) {\n        tailscaleStatus.innerHTML = `\n          <span style=\"color: #4caf50;\">Connected</span>\n          <span style=\"color: var(--muted); margin-left: 8px;\">${data.self?.hostname} (${data.self?.ip})</span>\n          <span style=\"color: var(--muted); margin-left: 8px;\">| ${data.deviceCount} devices</span>\n        `;\n      } else if (data.installed) {\n        tailscaleStatus.innerHTML = `<span style=\"color: #ff9800;\">Not connected</span>`;\n      } else {\n        tailscaleStatus.innerHTML = `<span style=\"color: var(--muted);\">Not available</span>`;\n        tailscaleCheckbox.disabled = true;\n      }\n    } catch (e) {\n      tailscaleStatus.innerHTML = `<span style=\"color: var(--muted);\">Could not check status</span>`;\n    }\n\n    // Update URL preview in real-time\n    function updateUrlPreview() {\n      const subdomain = subdomainInput.value || 'subdomain';\n      const dnsType = document.querySelector('input[name=\"dns-type\"]:checked').value;\n      const sslType = document.querySelector('input[name=\"ssl-type\"]:checked').value;\n\n      let url = '';\n      if (SITE.routingMode === 'subdirectory' && SITE.domain) {\n        // Subdirectory mode: domain.com/app\n        url = `https://${SITE.domain}/${subdomain}`;\n      } else if (dnsType === 'private') {\n        const protocol = sslType === 'none' ? 'http' : 'https';\n        url = `${protocol}://${buildDomain(subdomain)}`;\n      } else if (dnsType === 'public') {\n        const protocol = sslType === 'none' ? 'http' : 'https';\n        const domain = SITE.domain || subdomain;\n        url = SITE.domain ? `${protocol}://${subdomain}.${SITE.domain}` : `${protocol}://${subdomain}`;\n      } else {\n        const port = portInput.value || appTemplate.defaultPort || DC.DEFAULTS.SERVICE_PORT;\n        url = `http://${ipInput.value}:${port}`;\n      }\n      urlPreview.textContent = url;\n    }\n\n    // Attach listeners\n    subdomainInput.oninput = updateUrlPreview;\n    ipInput.oninput = updateUrlPreview;\n    portInput.oninput = updateUrlPreview;\n    document.querySelectorAll('input[name=\"dns-type\"]').forEach(radio => {\n      radio.onchange = updateUrlPreview;\n    });\n    document.querySelectorAll('input[name=\"ssl-type\"]').forEach(radio => {\n      radio.onchange = updateUrlPreview;\n    });\n\n    updateUrlPreview();\n\n    // Close app selector, open deploy config\n    modal.classList.remove('show');\n    deployModal.classList.add('show');\n\n    // Store app template for deployment\n    deployModal.dataset.appTemplate = JSON.stringify(appTemplate);\n  }\n\n  // Add app to grid with full Docker deployment\n  async function addAppToGrid(deployConfig) {\n    const appTemplate = deployConfig.appTemplate;\n    const customApps = safeGetJSON(APPS_KEY, []);\n\n    // Check if using existing container\n    const usingExisting = appTemplate._useExisting && appTemplate._existingContainer;\n\n    // Check if app already exists - skip if using existing container (user already confirmed)\n    const existingApp = customApps.find(a => a.id === deployConfig.subdomain);\n    if (existingApp && !usingExisting) {\n      const confirmed = confirm(`An app with subdomain \"${deployConfig.subdomain}\" already exists. Redeploy?`);\n      if (!confirmed) return;\n    }\n    // Remove from localStorage to allow redeployment/update\n    if (existingApp) {\n      const index = customApps.indexOf(existingApp);\n      customApps.splice(index, 1);\n      safeSet(APPS_KEY, JSON.stringify(customApps));\n    }\n\n    // Check port availability before deployment (skip if using existing container)\n    if (!usingExisting) {\n      const portToUse = deployConfig.port || appTemplate.defaultPort || 8080;\n      showNotification(`Checking port ${portToUse} availability...`, 'info', 0);\n\n      const portCheck = await checkPortAvailability(portToUse);\n      if (!portCheck.available) {\n        const suggestedPort = await getSuggestedPort(appTemplate.defaultPort || 8080);\n        const useAlternate = confirm(\n          `Port ${portToUse} is already in use by ${portCheck.conflict?.usedBy || 'another container'}.\\n\\n` +\n          `Would you like to use port ${suggestedPort} instead?`\n        );\n        if (useAlternate) {\n          deployConfig.port = suggestedPort;\n        } else {\n          showNotification('Deployment cancelled - port conflict', 'error', 5000);\n          return;\n        }\n      }\n    } else {\n      // Use existing container's port\n      deployConfig.port = appTemplate._existingContainer.primaryPort;\n    }\n    showNotification(\n      usingExisting\n        ? `Configuring ${appTemplate.name} with existing container...`\n        : `Deploying ${appTemplate.name}...`,\n      'info', 0\n    );\n\n    try {\n      // Prepare deployment config from user's choices\n      const apiDeployConfig = {\n        appId: appTemplate.id,\n        config: {\n          subdomain: deployConfig.subdomain,\n          ip: deployConfig.ip,\n          createDns: deployConfig.dnsType === 'private',  // Only create DNS for private\n          port: deployConfig.port || appTemplate.defaultPort || null,  // Use custom, template default, or null\n          sslType: deployConfig.sslType,\n          dnsType: deployConfig.dnsType,\n          tailscaleOnly: deployConfig.tailscaleOnly || false,  // Tailscale-only access restriction\n          mediaPath: deployConfig.mediaPath || null,  // Media folder path for media apps\n          plexClaimToken: deployConfig.plexClaimToken || null,  // Plex claim token for auto-claim\n          customVolumes: deployConfig.customVolumes || null  // Custom volume mount overrides\n        }\n      };\n\n      // Add existing container info if using existing\n      if (usingExisting) {\n        apiDeployConfig.config.useExisting = true;\n        apiDeployConfig.config.existingContainerId = appTemplate._existingContainer.id;\n        apiDeployConfig.config.existingPort = appTemplate._existingContainer.primaryPort;\n        // Use existing container's port if no custom port specified\n        if (!deployConfig.port && appTemplate._existingContainer.primaryPort) {\n          apiDeployConfig.config.port = appTemplate._existingContainer.primaryPort;\n        }\n      }\n\n      // DC-CATALOG-3: deploy through shipdeck (no Docker daemon). The\n      // bridge renders the catalog entry server-side and runs the OCI\n      // image as a hardened systemd service. Same modal, same fields.\n      const catalogPayload = {\n        app: appTemplate.id,\n        port: deployConfig.port || appTemplate.defaultPort || null,\n        subdomain: deployConfig.subdomain || '',\n        media_path: deployConfig.mediaPath || '',\n        env: deployConfig.plexClaimToken ? { PLEX_CLAIM: deployConfig.plexClaimToken } : {}\n      };\n\n      const response = await secureFetch('/api/v1/deploys/catalog/deploy', {\n        method: 'POST',\n        headers: { 'Content-Type': 'application/json' },\n        body: JSON.stringify(catalogPayload)\n      });\n\n      const result = await response.json();\n\n      if (result.success) {\n        // Add to saved apps (store IP for later deletion)\n        const newApp = {\n          id: deployConfig.subdomain,  // Use subdomain as ID\n          name: appTemplate.name,\n          logo: `/assets/${appTemplate.id}.png`,\n          containerId: null,  // shipdeck deploys have no docker container id\n          url: result.url || `http://127.0.0.1:${catalogPayload.port}`,\n          ip: deployConfig.ip,  // Store IP for DNS record deletion\n          appTemplate: appTemplate.id,  // Store original template ID\n          tailscaleOnly: deployConfig.tailscaleOnly || false  // Tailscale protection status\n        };\n        customApps.push(newApp);\n        safeSet(APPS_KEY, JSON.stringify(customApps));\n\n        // Add to APPS array and rebuild grid\n        // Access APPS from parent scope via window\n        if (window.APPS && !window.APPS.some(a => a.id === appTemplate.id)) {\n          window.APPS.push(newApp);\n          if (typeof window.buildGrid === 'function') {\n            window.buildGrid();\n          }\n          if (typeof window.refreshAll === 'function') {\n            setTimeout(() => window.refreshAll(), 500);\n          }\n        }\n\n        // Show success with URL (and warning if DNS failed)\n        let message = result.usedExisting\n          ? `${appTemplate.name} configured with existing container!\\nURL: ${result.url}`\n          : `${appTemplate.name} deployed successfully!\\nURL: ${result.url}`;\n        if (result.warning) {\n          message += `\\n\\n\u26A0 Warning: ${result.warning}`;\n        }\n\n        showNotification(message, 'success', 8000);\n\n        // Clean up temporary properties\n        delete appTemplate._useExisting;\n        delete appTemplate._existingContainer;\n        \n        // For HTTPS URLs, check SSL certificate status\n        if (result.url && result.url.startsWith('https://')) {\n          checkSSLCertificate(result.url, appTemplate.name);\n        }\n\n        // Show setup instructions if available\n        if (result.setupInstructions && result.setupInstructions.length > 0) {\n          setTimeout(() => {\n            const instructions = result.setupInstructions.join('\\n');\n            showNotification(`Setup Instructions for ${appTemplate.name}: ${instructions}`, 'info', 10000);\n          }, 1000);\n        }\n      } else {\n        throw new Error(result.error || 'Deployment failed');\n      }\n    } catch (error) {\n      errorHandler.logError('[AppSelector] Deployment', error, { function: 'deploy' });\n      showNotification(\n        `Failed to deploy ${appTemplate.name}: ${error.message}`,\n        'error',\n        8000\n      );\n    }\n  }\n\n  // Check SSL certificate status and notify when ready\n  async function checkSSLCertificate(url, appName) {\n    showNotification(`\u23F3 Generating SSL certificate for ${appName}...`, 'warning', 60000);\n    \n    let attempts = 0;\n    const maxAttempts = 12; // 60 seconds total (5 second intervals)\n    \n    const checkCert = async () => {\n      attempts++;\n      \n      try {\n        // Try to fetch the URL - if SSL works, this will succeed\n        const response = await fetch(url, { \n          method: 'HEAD',\n          mode: 'no-cors' // Avoid CORS issues\n        });\n        \n        // If we get here, SSL is working\n        showNotification(`\u2705 ${appName} is ready! SSL certificate generated.`, 'success', 5000);\n        return true;\n      } catch (error) {\n        // SSL not ready yet\n        if (attempts < maxAttempts) {\n          setTimeout(checkCert, 5000); // Check again in 5 seconds\n        } else {\n          showNotification(\n            `\u26A0\uFE0F ${appName} deployed but SSL certificate may still be generating.\\nTry refreshing in a moment if you see a certificate error.`,\n            'warning',\n            10000\n          );\n        }\n        return false;\n      }\n    };\n    \n    // Start checking after 3 seconds (give Caddy time to start)\n    setTimeout(checkCert, 3000);\n  }\n\n  // Load custom apps on startup\n  function loadCustomApps() {\n    const customApps = safeGetJSON(APPS_KEY, []);\n    customApps.forEach(app => {\n      if (!window.APPS.some(a => a.id === app.id)) {\n        window.APPS.push(app);\n      }\n    });\n  }\n\n  // Event listeners\n  document.getElementById('add-service-btn')?.addEventListener('click', () => {\n    buildAppSelector();\n    modal.classList.add('show');\n  });\n\n  // DC-163: programmatic deploy-config opener for the AI chat panel (and\n  // any other in-page consumer). Resolves the template id against the\n  // cached API templates (fetching them if needed), then opens the same\n  // deploy modal a manual click would. Returns false for unknown ids.\n  window.openDeployConfigFor = async function (templateId) {\n    if (!apiTemplates) {\n      const okFetch = await fetchAppTemplates();\n      if (!okFetch) return false;\n    }\n    const key = String(templateId || '').toLowerCase();\n    const entry = Object.entries(apiTemplates).find(([id]) => id.toLowerCase() === key);\n    if (!entry) return false;\n    const app = { id: entry[0], ...entry[1] };\n    if (app.isDashboardWidget) {\n      await buildAppSelector();\n      modal.classList.add('show');\n      return 'selector'; // widget \u2014 point at the selector grid instead\n    }\n    await showDeployConfig(app);\n    return true;\n  };\n\n  wireModal(modal, document.getElementById('app-selector-cancel'));\n\n  // Deploy modal event listeners\n  const deployModal = document.getElementById('app-deploy-modal');\n\n  document.getElementById('app-deploy-cancel')?.addEventListener('click', () => {\n    deployModal.classList.remove('show');\n  });\n\n  document.getElementById('app-deploy-confirm')?.addEventListener('click', () => {\n    // Get user configuration\n    const appTemplate = JSON.parse(deployModal.dataset.appTemplate);\n    const mediaPath = document.getElementById('deploy-media-path').value.trim();\n\n    // Collect custom volume overrides\n    const customVolumes = [];\n    document.querySelectorAll('#volume-mounts-list .vol-host-path').forEach(input => {\n      customVolumes.push({ hostPath: input.value.trim(), containerPath: input.dataset.containerPath });\n    });\n\n    const deployConfig = {\n      appTemplate: appTemplate,\n      subdomain: document.getElementById('deploy-subdomain').value.trim(),\n      dnsType: document.querySelector('input[name=\"dns-type\"]:checked').value,\n      sslType: document.querySelector('input[name=\"ssl-type\"]:checked').value,\n      ip: document.getElementById('deploy-ip').value.trim(),\n      port: document.getElementById('deploy-port').value.trim(),\n      tailscaleOnly: document.getElementById('deploy-tailscale-only').checked,\n      mediaPath: mediaPath || null,\n      plexClaimToken: document.getElementById('deploy-plex-claim')?.value.trim() || null,\n      customVolumes: customVolumes.length > 0 ? customVolumes : null,\n      resources: {\n        cpus: parseFloat(document.getElementById('deploy-cpu-limit').value) || 0,\n        memory: parseFloat(document.getElementById('deploy-memory-limit').value) || 0,\n      }\n    };\n\n    // Validate subdomain\n    if (!deployConfig.subdomain) {\n      showNotification('Please enter a subdomain or domain name', 'warning');\n      return;\n    }\n\n    // Validate media path for media apps\n    if (appTemplate.mediaMount?.required && !mediaPath) {\n      showNotification('Please enter a media library path for this application', 'warning');\n      return;\n    }\n\n    // Close deploy modal\n    deployModal.classList.remove('show');\n\n    // Start deployment\n    addAppToGrid(deployConfig);\n  });\n\n  wireModal(deployModal);\n\n  // ===== FOLDER BROWSER FUNCTIONALITY =====\n  const folderBrowserModal = document.getElementById('folder-browser-modal');\n  const folderBrowserPath = document.getElementById('folder-browser-path');\n  const folderBrowserList = document.getElementById('folder-browser-list');\n  const folderBrowserSelected = document.getElementById('folder-browser-selected');\n  const folderBrowserSelectedList = document.getElementById('folder-browser-selected-list');\n  let currentBrowserPath = '';\n  let selectedFolders = [];\n  let targetMediaInput = null;\n\n  window.openFolderBrowser = function(mediaInput) {\n    targetMediaInput = mediaInput;\n    selectedFolders = mediaInput.value.split(',').map(p => p.trim()).filter(p => p);\n    currentBrowserPath = '';\n    updateSelectedFoldersDisplay();\n    loadFolderContents('');\n    folderBrowserModal.classList.add('show');\n  };\n\n  async function loadFolderContents(path) {\n    folderBrowserPath.textContent = path || 'Select a drive...';\n    folderBrowserList.innerHTML = '<div style=\"padding: 20px; text-align: center; color: var(--muted);\">Loading...</div>';\n\n    try {\n      const response = await fetch(`/api/v1/browse/directories?path=${encodeURIComponent(path)}`);\n      const result = await response.json();\n\n      if (!result.success) {\n        folderBrowserList.innerHTML = `<div style=\"padding: 20px; text-align: center; color: var(--error);\">Error: ${escapeHtml(result.error)}</div>`;\n        return;\n      }\n\n      currentBrowserPath = result.path || '';\n      folderBrowserPath.textContent = currentBrowserPath || 'Select a drive...';\n\n      let html = '';\n\n      // Add parent folder navigation\n      if (result.parent && result.parent !== result.path) {\n        html += `<div class=\"folder-item\" data-path=\"${escapeHtml(result.parent)}\" style=\"padding: 12px 16px; border-bottom: 1px solid var(--border); cursor: pointer; display: flex; align-items: center; gap: 10px;\">\n          <span style=\"font-size: 1.2rem;\">\u2B06\uFE0F</span>\n          <span style=\"color: var(--muted);\">.. Parent Directory</span>\n        </div>`;\n      }\n\n      // Add folders\n      if (result.items.length === 0 && !result.parent) {\n        html += '<div style=\"padding: 20px; text-align: center; color: var(--muted);\">No browseable drives configured. Check your docker-compose.yml volume mounts.</div>';\n      } else if (result.items.length === 0) {\n        html += '<div style=\"padding: 20px; text-align: center; color: var(--muted);\">No subfolders found</div>';\n      } else {\n        result.items.forEach(item => {\n          const icon = item.type === 'drive' ? '\uD83D\uDCBE' : '\uD83D\uDCC1';\n          const isSelected = selectedFolders.includes(item.path);\n          const selectedStyle = isSelected ? 'background: color-mix(in srgb, var(--success) 20%, transparent);' : '';\n          html += `<div class=\"folder-item\" data-path=\"${escapeHtml(item.path)}\" style=\"padding: 12px 16px; border-bottom: 1px solid var(--border); cursor: pointer; display: flex; align-items: center; gap: 10px; ${selectedStyle}\">\n            <span style=\"font-size: 1.2rem;\">${icon}</span>\n            <span style=\"flex: 1;\">${escapeHtml(item.name)}</span>\n            ${isSelected ? '<span style=\"color: var(--success);\">\u2713</span>' : ''}\n          </div>`;\n        });\n      }\n\n      folderBrowserList.innerHTML = html;\n\n      // Add click handlers\n      folderBrowserList.querySelectorAll('.folder-item').forEach(item => {\n        item.addEventListener('click', () => {\n          loadFolderContents(item.dataset.path);\n        });\n        item.addEventListener('mouseenter', () => {\n          item.style.background = 'var(--card-bg)';\n        });\n        item.addEventListener('mouseleave', () => {\n          const isSelected = selectedFolders.includes(item.dataset.path);\n          item.style.background = isSelected ? 'color-mix(in srgb, var(--success) 20%, transparent)' : '';\n        });\n      });\n\n    } catch (error) {\n      folderBrowserList.innerHTML = `<div style=\"padding: 20px; text-align: center; color: var(--error);\">Failed to load: ${escapeHtml(error.message)}</div>`;\n    }\n  }\n\n  function updateSelectedFoldersDisplay() {\n    if (selectedFolders.length === 0) {\n      folderBrowserSelected.style.display = 'none';\n      return;\n    }\n    folderBrowserSelected.style.display = 'block';\n    folderBrowserSelectedList.innerHTML = selectedFolders.map(path => `\n      <span style=\"padding: 6px 12px; background: var(--card-bg); border: 1px solid var(--success); border-radius: 4px; display: flex; align-items: center; gap: 6px;\">\n        ${escapeHtml(path)}\n        <button type=\"button\" onclick=\"removeSelectedFolder('${escapeHtml(path)}')\" style=\"background: none; border: none; cursor: pointer; color: var(--error); font-size: 1rem; padding: 0;\">\u00D7</button>\n      </span>\n    `).join('');\n  }\n\n  window.removeSelectedFolder = function(path) {\n    selectedFolders = selectedFolders.filter(p => p !== path);\n    updateSelectedFoldersDisplay();\n    loadFolderContents(currentBrowserPath); // Refresh to update checkmarks\n  };\n\n  document.getElementById('folder-browser-select-current').addEventListener('click', () => {\n    if (currentBrowserPath && !selectedFolders.includes(currentBrowserPath)) {\n      selectedFolders.push(currentBrowserPath);\n      updateSelectedFoldersDisplay();\n      loadFolderContents(currentBrowserPath); // Refresh to show checkmark\n    }\n  });\n\n  wireModal(folderBrowserModal, document.getElementById('folder-browser-cancel'));\n\n  document.getElementById('folder-browser-done').addEventListener('click', () => {\n    if (targetMediaInput) {\n      targetMediaInput.value = selectedFolders.join(', ');\n    }\n    folderBrowserModal.classList.remove('show');\n  });\n\n  // Load custom apps on page load\n  loadCustomApps();\n})();\n;\n// Recipe System \u2014 multi-container stack deployment\n(function() {\n  // === RECIPE DEPLOY WIZARD MODAL ===\n  injectModal('recipe-deploy-modal', `<div id=\"recipe-deploy-modal\" class=\"weather-modal\">\n    <div class=\"weather-modal-content\" style=\"min-width: 620px; max-width: 740px;\">\n      <h3 id=\"recipe-deploy-title\">Deploy Recipe</h3>\n\n      <!-- Step indicator -->\n      <div id=\"recipe-steps\" style=\"display: flex; gap: 4px; margin: 16px 0 24px;\">\n        <div class=\"recipe-step active\" data-step=\"1\"><span>1</span> Components</div>\n        <div class=\"recipe-step\" data-step=\"2\"><span>2</span> Configuration</div>\n        <div class=\"recipe-step\" data-step=\"3\"><span>3</span> Review</div>\n        <div class=\"recipe-step\" data-step=\"4\"><span>4</span> Progress</div>\n      </div>\n\n      <!-- Step 1: Component Selection -->\n      <div id=\"recipe-step-1\" class=\"recipe-step-panel\">\n        <label class=\"form-label-accent-sm\">Select Components:</label>\n        <div id=\"recipe-component-list\" style=\"display: grid; gap: 10px; margin-top: 8px;\"></div>\n      </div>\n\n      <!-- Step 2: Shared Configuration -->\n      <div id=\"recipe-step-2\" class=\"recipe-step-panel\" style=\"display:none;\">\n        <div style=\"display: grid; gap: 16px;\">\n          <!-- Shared volumes -->\n          <div id=\"recipe-volumes-section\" style=\"display:none;\">\n            <label class=\"form-label-accent-sm\">Shared Volumes:</label>\n            <div id=\"recipe-volume-list\" style=\"display: grid; gap: 10px; margin-top: 8px;\"></div>\n          </div>\n\n          <!-- Timezone -->\n          <div>\n            <label class=\"form-label-accent-sm\">Timezone:</label>\n            <input type=\"text\" id=\"recipe-timezone\" value=\"UTC\" placeholder=\"e.g. America/New_York\"\n              style=\"width: 100%; padding: 8px 12px; background: var(--card-bg); color: var(--fg); border: 1px solid var(--border); border-radius: 6px;\" />\n          </div>\n\n          <!-- Target IP -->\n          <div>\n            <label class=\"form-label-accent-sm\">Target IP Address:</label>\n            <input type=\"text\" id=\"recipe-ip\" value=\"host.docker.internal\" placeholder=\"localhost or IP\"\n              style=\"width: 100%; padding: 8px 12px; background: var(--card-bg); color: var(--fg); border: 1px solid var(--border); border-radius: 6px;\" />\n            <div class=\"form-hint-sm\">IP where containers expose ports</div>\n          </div>\n\n          <!-- Tailscale -->\n          <label class=\"checkbox-label\">\n            <input type=\"checkbox\" id=\"recipe-tailscale\" />\n            <span>Restrict to Tailscale network only</span>\n          </label>\n        </div>\n      </div>\n\n      <!-- Step 3: Review -->\n      <div id=\"recipe-step-3\" class=\"recipe-step-panel\" style=\"display:none;\">\n        <div id=\"recipe-review-content\" style=\"font-size: 0.9rem; line-height: 1.7;\"></div>\n      </div>\n\n      <!-- Step 4: Progress -->\n      <div id=\"recipe-step-4\" class=\"recipe-step-panel\" style=\"display:none;\">\n        <div id=\"recipe-progress-list\" style=\"display: grid; gap: 8px;\"></div>\n        <div id=\"recipe-deploy-result\" style=\"margin-top: 16px; display:none;\"></div>\n      </div>\n\n      <div class=\"weather-modal-buttons\" style=\"margin-top: 20px;\">\n        <button id=\"recipe-cancel\">Cancel</button>\n        <button id=\"recipe-prev\" class=\"btn-accent\" style=\"display:none;\">Back</button>\n        <button id=\"recipe-next\" class=\"btn-accent-solid\">Next</button>\n      </div>\n    </div>\n  </div>`);\n\n  // === STATE ===\n  let recipeTemplates = null;\n  let recipeCategories = null;\n  let currentRecipe = null;\n  let currentStep = 1;\n  let isPremium = false;\n\n  const deployModal = document.getElementById('recipe-deploy-modal');\n  const cancelBtn = document.getElementById('recipe-cancel');\n  const prevBtn = document.getElementById('recipe-prev');\n  const nextBtn = document.getElementById('recipe-next');\n\n  wireModal(deployModal, cancelBtn);\n\n  // === FETCH RECIPE TEMPLATES ===\n  async function fetchRecipeTemplates() {\n    try {\n      const resp = await fetch('/api/v1/recipes/templates');\n      const data = await resp.json();\n      if (data.success) {\n        recipeTemplates = data.templates;\n        recipeCategories = data.categories;\n        return true;\n      }\n      // Premium required \u2014 templates API gated\n      if (resp.status === 403) {\n        isPremium = false;\n        return false;\n      }\n    } catch (e) {\n      console.warn('Failed to fetch recipe templates:', e.message);\n    }\n    return false;\n  }\n\n  // === CHECK PREMIUM ===\n  async function checkRecipePremium() {\n    try {\n      const resp = await fetch('/api/v1/license/feature/recipes');\n      const data = await resp.json();\n      isPremium = data.available;\n    } catch {\n      isPremium = false;\n    }\n    return isPremium;\n  }\n\n  // === RENDER RECIPE CARDS INTO APP SELECTOR ===\n  // This function is called by the app selector to inject recipe cards\n  window.renderRecipeCards = async function(grid) {\n    await checkRecipePremium();\n\n    // Build recipe data \u2014 we can show card metadata even without premium\n    // (cards just show a lock and prompt to upgrade)\n    let recipes;\n    if (isPremium && recipeTemplates) {\n      recipes = recipeTemplates;\n    } else {\n      // Show hardcoded preview cards when not premium\n      recipes = getPreviewRecipes();\n    }\n\n    if (!recipes || recipes.length === 0) return;\n\n    // Category header\n    const header = document.createElement('div');\n    header.className = 'app-category-header';\n    header.innerHTML = `\\uD83E\\uDDEA Recipes`;\n    header.style.borderBottomColor = '#8e44ad';\n    grid.appendChild(header);\n\n    const recipeList = Array.isArray(recipes) ? recipes : Object.values(recipes);\n    recipeList.sort((a, b) => (b.popularity || 0) - (a.popularity || 0));\n\n    for (const recipe of recipeList) {\n      const option = document.createElement('div');\n      option.className = 'app-option';\n      option.style.position = 'relative';\n\n      const componentBadge = `<div style=\"font-size: 0.65rem; padding: 2px 6px; border-radius: 4px; margin-top: 4px; background: rgba(142,68,173,0.2); color: #a855f7;\">${recipe.componentCount || recipe.components?.length || '?'} apps</div>`;\n\n      const lockOverlay = !isPremium ? `<div style=\"position: absolute; top: 6px; right: 6px; font-size: 0.65rem; padding: 2px 8px; border-radius: 10px; background: rgba(241,196,15,0.2); color: #f1c40f; font-weight: 600;\">PREMIUM</div>` : '';\n\n      option.innerHTML = `\n        ${lockOverlay}\n        <div class=\"app-option-icon\">${escapeHtml(recipe.icon || '\\uD83E\\uDDEA')}</div>\n        <div class=\"app-option-name\">${escapeHtml(recipe.name)}</div>\n        <div class=\"app-option-desc\">${escapeHtml(recipe.description || '')}</div>\n        ${componentBadge}\n      `;\n\n      option.onclick = () => {\n        if (!isPremium) {\n          showNotification('Recipes require a DashCaddy Premium license. Click the License button to activate.', 'warning', 5000);\n          if (window.openLicenseModal) window.openLicenseModal();\n          return;\n        }\n        openRecipeDeployWizard(recipe);\n      };\n\n      grid.appendChild(option);\n    }\n  };\n\n  function getPreviewRecipes() {\n    return [\n      { id: 'htpc-suite', name: 'HTPC Suite', icon: '\\uD83C\\uDFAC', description: 'Complete media automation: find, download, organize, and stream', componentCount: 6, popularity: 98 },\n      { id: 'nextcloud-complete', name: 'Nextcloud Complete', icon: '\\u2601\\uFE0F', description: 'Full productivity suite: cloud storage, office editing, and collaboration', componentCount: 4, popularity: 90 },\n      { id: 'smart-home', name: 'Smart Home Hub', icon: '\\uD83C\\uDFE0', description: 'Home automation: control, automate, and monitor IoT devices', componentCount: 4, popularity: 88 },\n      { id: 'dev-environment', name: 'Dev Environment', icon: '\\uD83D\\uDCBB', description: 'Self-hosted development workflow: Git, CI/CD, IDE, and database', componentCount: 4, popularity: 82 }\n    ];\n  }\n\n  // === RECIPE DEPLOY WIZARD ===\n  function openRecipeDeployWizard(recipe) {\n    currentRecipe = recipe;\n    currentStep = 1;\n\n    // Close app selector\n    const appSelectorModal = document.getElementById('app-selector-modal');\n    if (appSelectorModal) appSelectorModal.classList.remove('show');\n\n    document.getElementById('recipe-deploy-title').textContent = `Deploy ${recipe.name}`;\n\n    // Reset steps\n    updateStepUI();\n    renderStep1();\n\n    deployModal.classList.add('show');\n  }\n\n  function updateStepUI() {\n    // Step indicators\n    document.querySelectorAll('#recipe-steps .recipe-step').forEach(el => {\n      const step = parseInt(el.dataset.step);\n      el.classList.toggle('active', step === currentStep);\n      el.classList.toggle('completed', step < currentStep);\n    });\n\n    // Step panels\n    for (let i = 1; i <= 4; i++) {\n      const panel = document.getElementById(`recipe-step-${i}`);\n      if (panel) panel.style.display = i === currentStep ? '' : 'none';\n    }\n\n    // Navigation buttons\n    prevBtn.style.display = currentStep > 1 && currentStep < 4 ? '' : 'none';\n    if (currentStep === 4) {\n      nextBtn.style.display = 'none';\n      cancelBtn.textContent = 'Close';\n    } else if (currentStep === 3) {\n      nextBtn.textContent = '\\uD83D\\uDE80 Deploy';\n      nextBtn.style.display = '';\n      cancelBtn.textContent = 'Cancel';\n    } else {\n      nextBtn.textContent = 'Next';\n      nextBtn.style.display = '';\n      cancelBtn.textContent = 'Cancel';\n    }\n  }\n\n  // Step 1: Component selection\n  function renderStep1() {\n    const list = document.getElementById('recipe-component-list');\n    list.innerHTML = '';\n\n    const components = currentRecipe.components || [];\n    for (const comp of components) {\n      const el = document.createElement('div');\n      el.style.cssText = 'display: flex; align-items: center; gap: 12px; padding: 12px; border-radius: 8px; background: var(--card-bg); border: 1px solid var(--border);';\n\n      const isRequired = comp.required;\n      const isInternal = comp.internal;\n\n      el.innerHTML = `\n        <input type=\"checkbox\" ${isRequired ? 'checked disabled' : 'checked'} data-component-id=\"${comp.id}\"\n          style=\"width: 18px; height: 18px; accent-color: var(--accent);\" />\n        <div style=\"flex: 1;\">\n          <div style=\"font-weight: 600; font-size: 0.9rem;\">${escapeHtml(comp.role || comp.id)}</div>\n          <div style=\"font-size: 0.78rem; color: var(--muted);\">\n            ${comp.templateRef ? escapeHtml(comp.templateRef) : 'Built-in'}\n            ${isRequired ? '<span style=\"color: var(--accent); margin-left: 6px;\">Required</span>' : '<span style=\"color: var(--muted); margin-left: 6px;\">Optional</span>'}\n            ${isInternal ? '<span style=\"color: var(--muted); margin-left: 6px;\">(Internal)</span>' : ''}\n          </div>\n          ${comp.note ? `<div style=\"font-size: 0.75rem; color: var(--warn-fg); margin-top: 4px;\">\\u26A0 ${escapeHtml(comp.note)}</div>` : ''}\n        </div>\n      `;\n      list.appendChild(el);\n    }\n  }\n\n  // Step 2: Shared configuration\n  function renderStep2() {\n    const volumeSection = document.getElementById('recipe-volumes-section');\n    const volumeList = document.getElementById('recipe-volume-list');\n\n    const sharedVolumes = currentRecipe.sharedVolumes;\n    if (sharedVolumes && Object.keys(sharedVolumes).length > 0) {\n      volumeSection.style.display = '';\n      volumeList.innerHTML = '';\n\n      for (const [key, vol] of Object.entries(sharedVolumes)) {\n        const el = document.createElement('div');\n        el.style.cssText = 'display: grid; gap: 4px;';\n        el.innerHTML = `\n          <label style=\"font-weight: 500; font-size: 0.85rem;\">${escapeHtml(vol.label || key)}</label>\n          <input type=\"text\" data-volume-key=\"${key}\" value=\"${escapeHtml(vol.defaultPath || '')}\"\n            placeholder=\"${escapeHtml(vol.defaultPath || '/path')}\"\n            style=\"width: 100%; padding: 8px 12px; background: var(--card-bg); color: var(--fg); border: 1px solid var(--border); border-radius: 6px; font-family: monospace; font-size: 0.85rem;\" />\n          <div class=\"form-hint-sm\">${escapeHtml(vol.description || '')}</div>\n        `;\n        volumeList.appendChild(el);\n      }\n    } else {\n      volumeSection.style.display = 'none';\n    }\n  }\n\n  // Step 3: Review\n  function renderStep3() {\n    const content = document.getElementById('recipe-review-content');\n    const selectedComponents = getSelectedComponents();\n\n    const volumeInputs = document.querySelectorAll('#recipe-volume-list input[data-volume-key]');\n    const volumes = {};\n    volumeInputs.forEach(input => {\n      volumes[input.dataset.volumeKey] = input.value;\n    });\n\n    const tz = document.getElementById('recipe-timezone').value || 'UTC';\n    const ip = document.getElementById('recipe-ip').value || 'host.docker.internal';\n    const tailscale = document.getElementById('recipe-tailscale').checked;\n\n    content.innerHTML = `\n      <div style=\"font-weight: 600; font-size: 1rem; margin-bottom: 12px;\">${escapeHtml(currentRecipe.name)}</div>\n      <div style=\"color: var(--muted); margin-bottom: 16px;\">${escapeHtml(currentRecipe.description || '')}</div>\n\n      <div style=\"margin-bottom: 12px;\">\n        <strong>Components (${selectedComponents.length}):</strong>\n        <div style=\"display: grid; gap: 4px; margin-top: 6px;\">\n          ${selectedComponents.map(c => `<div style=\"padding: 4px 0; font-size: 0.85rem;\">\n            \\u2022 <strong>${escapeHtml(c.role || c.id)}</strong> ${c.internal ? '<span style=\"color:var(--muted)\">(internal)</span>' : ''}\n          </div>`).join('')}\n        </div>\n      </div>\n\n      ${Object.keys(volumes).length > 0 ? `<div style=\"margin-bottom: 12px;\">\n        <strong>Volumes:</strong>\n        ${Object.entries(volumes).map(([k, v]) => `<div style=\"font-size: 0.85rem; font-family: monospace; color: var(--muted);\">${k}: ${escapeHtml(v)}</div>`).join('')}\n      </div>` : ''}\n\n      <div style=\"font-size: 0.85rem; color: var(--muted);\">\n        Timezone: ${escapeHtml(tz)} &bull; IP: ${escapeHtml(ip)} ${tailscale ? '&bull; Tailscale only' : ''}\n      </div>\n\n      ${currentRecipe.network ? `<div style=\"font-size: 0.85rem; color: var(--muted); margin-top: 4px;\">Docker network: <code>${escapeHtml(currentRecipe.network.name)}</code></div>` : ''}\n    `;\n  }\n\n  function getSelectedComponents() {\n    const checkboxes = document.querySelectorAll('#recipe-component-list input[data-component-id]');\n    const selectedIds = new Set();\n    checkboxes.forEach(cb => {\n      if (cb.checked) selectedIds.add(cb.dataset.componentId);\n    });\n\n    // Always include required components\n    const components = currentRecipe.components || [];\n    components.filter(c => c.required).forEach(c => selectedIds.add(c.id));\n\n    return components.filter(c => selectedIds.has(c.id));\n  }\n\n  // Step 4: Deploy\n  async function executeDeploy() {\n    const progressList = document.getElementById('recipe-progress-list');\n    const resultEl = document.getElementById('recipe-deploy-result');\n    resultEl.style.display = 'none';\n    progressList.innerHTML = '';\n\n    const selectedComponents = getSelectedComponents();\n\n    // Show progress items\n    for (const comp of selectedComponents) {\n      const el = document.createElement('div');\n      el.id = `recipe-progress-${comp.id}`;\n      el.style.cssText = 'display: flex; align-items: center; gap: 10px; padding: 10px 12px; border-radius: 6px; background: var(--card-bg); border: 1px solid var(--border); font-size: 0.85rem;';\n      el.innerHTML = `\n        <span class=\"recipe-progress-icon\" style=\"font-size: 1.1rem;\">\\u23F3</span>\n        <span style=\"flex:1; font-weight: 500;\">${escapeHtml(comp.role || comp.id)}</span>\n        <span class=\"recipe-progress-status\" style=\"color: var(--muted);\">Queued</span>\n      `;\n      progressList.appendChild(el);\n    }\n\n    // Collect config\n    const volumeInputs = document.querySelectorAll('#recipe-volume-list input[data-volume-key]');\n    const volumes = {};\n    volumeInputs.forEach(input => {\n      volumes[input.dataset.volumeKey] = input.value;\n    });\n\n    const config = {\n      selectedComponents: selectedComponents.map(c => c.id),\n      sharedConfig: {\n        ip: document.getElementById('recipe-ip').value || 'host.docker.internal',\n        timezone: document.getElementById('recipe-timezone').value || 'UTC',\n        tailscaleOnly: document.getElementById('recipe-tailscale').checked,\n        volumes\n      },\n      componentOverrides: {}\n    };\n\n    // Mark all as deploying\n    for (const comp of selectedComponents) {\n      updateProgressItem(comp.id, 'deploying', 'Deploying...');\n    }\n\n    try {\n      const resp = await secureFetch('/api/v1/recipes/deploy', {\n        method: 'POST',\n        headers: { 'Content-Type': 'application/json' },\n        body: JSON.stringify({ recipeId: currentRecipe.id, config })\n      });\n      const data = await resp.json();\n\n      if (data.success) {\n        // Mark deployed components\n        for (const deployed of (data.deployed || [])) {\n          updateProgressItem(deployed.id, 'success', deployed.url ? `Running \\u2192 ${deployed.url}` : 'Running');\n        }\n        // Mark errors\n        for (const err of (data.errors || [])) {\n          updateProgressItem(err.componentId, 'error', err.error);\n        }\n\n        resultEl.style.display = '';\n        resultEl.innerHTML = `\n          <div style=\"padding: 14px; border-radius: 8px; background: rgba(46,204,113,0.1); border: 1px solid rgba(46,204,113,0.3);\">\n            <div style=\"font-weight: 600; color: var(--ok-fg); margin-bottom: 6px;\">${escapeHtml(data.message || 'Deployed!')}</div>\n            ${data.setupInstructions ? `<div style=\"font-size: 0.8rem; color: var(--muted); margin-top: 8px;\">\n              <strong>Setup tips:</strong>\n              <ul style=\"margin: 4px 0 0 16px; padding: 0;\">${data.setupInstructions.map(s => `<li>${escapeHtml(s)}</li>`).join('')}</ul>\n            </div>` : ''}\n          </div>\n        `;\n\n        showNotification(`${currentRecipe.name} recipe deployed successfully!`, 'success', 5000);\n\n        // Refresh dashboard\n        if (window.loadServices) window.loadServices();\n      } else {\n        resultEl.style.display = '';\n        resultEl.innerHTML = `<div style=\"padding: 14px; border-radius: 8px; background: rgba(231,76,60,0.1); border: 1px solid rgba(231,76,60,0.3); color: var(--bad-fg);\">\n          <strong>Deployment failed:</strong> ${escapeHtml(data.error || 'Unknown error')}\n        </div>`;\n        showNotification(`Recipe deployment failed: ${data.error}`, 'error', 5000);\n      }\n    } catch (e) {\n      resultEl.style.display = '';\n      resultEl.innerHTML = `<div style=\"padding: 14px; border-radius: 8px; background: rgba(231,76,60,0.1); border: 1px solid rgba(231,76,60,0.3); color: var(--bad-fg);\">\n        <strong>Network error:</strong> ${escapeHtml(e.message)}\n      </div>`;\n    }\n  }\n\n  function updateProgressItem(componentId, status, text) {\n    const el = document.getElementById(`recipe-progress-${componentId}`);\n    if (!el) return;\n    const icon = el.querySelector('.recipe-progress-icon');\n    const statusEl = el.querySelector('.recipe-progress-status');\n\n    if (status === 'deploying') {\n      icon.textContent = '\\u23F3';\n      statusEl.style.color = 'var(--accent)';\n    } else if (status === 'success') {\n      icon.textContent = '\\u2705';\n      statusEl.style.color = 'var(--ok-fg)';\n    } else if (status === 'error') {\n      icon.textContent = '\\u274C';\n      statusEl.style.color = 'var(--bad-fg)';\n    }\n    statusEl.textContent = text;\n  }\n\n  // === STEP NAVIGATION ===\n  nextBtn.addEventListener('click', () => {\n    if (currentStep === 3) {\n      currentStep = 4;\n      updateStepUI();\n      executeDeploy();\n      return;\n    }\n    if (currentStep < 3) {\n      currentStep++;\n      updateStepUI();\n      if (currentStep === 2) renderStep2();\n      if (currentStep === 3) renderStep3();\n    }\n  });\n\n  prevBtn.addEventListener('click', () => {\n    if (currentStep > 1 && currentStep < 4) {\n      currentStep--;\n      updateStepUI();\n    }\n  });\n\n  // === RECIPE CARD GROUPING ON DASHBOARD ===\n  // After dashboard loads, group cards that share a recipeId\n  window.groupRecipeCards = function() {\n    const cards = document.querySelectorAll('.service-card[data-recipe-id]');\n    if (cards.length === 0) return;\n\n    const groups = {};\n    cards.forEach(card => {\n      const recipeId = card.dataset.recipeId;\n      if (!groups[recipeId]) groups[recipeId] = [];\n      groups[recipeId].push(card);\n    });\n\n    for (const [recipeId, groupCards] of Object.entries(groups)) {\n      if (groupCards.length < 2) continue;\n\n      // Apply subtle visual grouping\n      groupCards.forEach((card, i) => {\n        card.style.borderLeft = '3px solid rgba(142,68,173,0.5)';\n        if (i === 0) {\n          // Add a recipe label to the first card\n          let label = card.querySelector('.recipe-group-label');\n          if (!label) {\n            label = document.createElement('div');\n            label.className = 'recipe-group-label';\n            label.style.cssText = 'position: absolute; top: -8px; left: 12px; font-size: 0.6rem; padding: 1px 8px; border-radius: 8px; background: rgba(142,68,173,0.3); color: #d4a5ff; font-weight: 600; text-transform: uppercase; letter-spacing: 0.5px;';\n            label.textContent = recipeId.replace(/-/g, ' ');\n            card.style.position = 'relative';\n            card.appendChild(label);\n          }\n        }\n      });\n    }\n  };\n\n  // === RECIPE MANAGEMENT ACTIONS ===\n  window.manageRecipe = async function(recipeId, action) {\n    const endpoint = `/api/v1/recipes/${recipeId}/${action}`;\n    const method = action === 'remove' ? 'DELETE' : 'POST';\n    const url = action === 'remove' ? `/api/v1/recipes/${recipeId}` : endpoint;\n\n    if (action === 'remove' && !confirm(`Remove the entire ${recipeId} recipe? This will delete all containers and configuration.`)) {\n      return;\n    }\n\n    try {\n      const resp = await secureFetch(url, { method });\n      const data = await resp.json();\n      if (data.success) {\n        showNotification(`Recipe ${action}: ${data.results?.filter(r => r.status !== 'failed').length || 0} components processed`, 'success', 4000);\n        if (window.loadServices) window.loadServices();\n      } else {\n        showNotification(`Recipe ${action} failed: ${data.error}`, 'error', 5000);\n      }\n    } catch (e) {\n      showNotification(`Network error: ${e.message}`, 'error', 5000);\n    }\n  };\n\n  // === INJECT CSS ===\n  const style = document.createElement('style');\n  style.textContent = `\n    .recipe-step {\n      flex: 1;\n      text-align: center;\n      padding: 8px 4px;\n      font-size: 0.78rem;\n      color: var(--muted);\n      border-bottom: 2px solid var(--border);\n      transition: all 0.2s;\n    }\n    .recipe-step span {\n      display: inline-flex;\n      align-items: center;\n      justify-content: center;\n      width: 20px;\n      height: 20px;\n      border-radius: 50%;\n      background: var(--border);\n      color: var(--muted);\n      font-size: 0.7rem;\n      font-weight: 700;\n      margin-right: 4px;\n    }\n    .recipe-step.active {\n      color: var(--accent);\n      border-bottom-color: var(--accent);\n    }\n    .recipe-step.active span {\n      background: var(--accent);\n      color: #fff;\n    }\n    .recipe-step.completed {\n      color: var(--ok-fg);\n      border-bottom-color: var(--ok-fg);\n    }\n    .recipe-step.completed span {\n      background: var(--ok-fg);\n      color: #fff;\n    }\n    .recipe-step-panel {\n      min-height: 180px;\n    }\n  `;\n  document.head.appendChild(style);\n\n  // === INIT ===\n  // Pre-fetch premium status on load\n  checkRecipePremium();\n})();\n;\n// ========== CADDY RELOAD BUTTON ==========\n(function() {\n  // Reload Caddy button handler\n  document.getElementById('reload-caddy-top')?.addEventListener('click', async () => {\n    const button = document.getElementById('reload-caddy-top');\n    const originalText = button.textContent;\n\n    try {\n      button.textContent = '\u23F3 Reloading...';\n      button.disabled = true;\n\n      const response = await secureFetch('/api/v1/caddy/reload', {\n        method: 'POST',\n        headers: { 'Content-Type': 'application/json' }\n      });\n\n      const result = await response.json();\n\n      if (response.ok && result.success) {\n        button.textContent = '\u2705 Reloaded!';\n        setTimeout(() => {\n          button.textContent = originalText;\n          button.disabled = false;\n        }, 2000);\n      } else {\n        throw new Error(result.error || 'Reload failed');\n      }\n    } catch (error) {\n      button.textContent = '\u274C Failed';\n      showNotification(`Failed to reload Caddy: ${error.message}`, 'error');\n      setTimeout(() => {\n        button.textContent = originalText;\n        button.disabled = false;\n      }, 2000);\n    }\n  });\n})();\n;\n// ========== ERROR LOG VIEWER (DC-052) ==========\n// DC-052: Adds Level / Context / Search / Time-range filters, server-side\n// pagination with Load More, click-to-expand stack frames, and a distinct\n// contexts dropdown backed by /api/v1/error-logs/contexts. Mirrors the\n// audit-log UX (DC-050) so operators can drill into a subsystem as easily\n// as they can audit who-did-what.\n(function() {\n  // Inject modal HTML. Same weather-modal shell as audit-log so styles\n  // are shared; wider min-width because error stacks need room to breathe.\n  injectModal('error-log-modal', `<div id=\"error-log-modal\" class=\"weather-modal\">\n    <div class=\"weather-modal-content\" style=\"min-width: 950px; max-width: 1150px;\">\n      <h3>\uD83D\uDCCB Error Logs</h3>\n      <p class=\"modal-subtitle\">\n        Errors and warnings from the DashCaddy API. Click a row to see the full stack trace.\n      </p>\n\n      <div style=\"display: flex; gap: 12px; margin-bottom: 12px; align-items: center; flex-wrap: wrap;\">\n        <label class=\"text-muted-sm\">Level:</label>\n        <select id=\"error-log-level\" style=\"padding: 6px 10px; border-radius: 6px; border: 1px solid var(--border); background: var(--bg); color: var(--fg); font-size: 0.85rem;\">\n          <option value=\"\">All</option>\n          <option value=\"ERR\">Errors</option>\n          <option value=\"WARN\">Warnings</option>\n          <option value=\"INFO\">Info</option>\n          <option value=\"DEBUG\">Debug</option>\n        </select>\n        <label class=\"text-muted-sm\">Context:</label>\n        <select id=\"error-log-context\" style=\"padding: 6px 10px; border-radius: 6px; border: 1px solid var(--border); background: var(--bg); color: var(--fg); font-size: 0.85rem; max-width: 220px;\">\n          <option value=\"\">All</option>\n        </select>\n        <label class=\"text-muted-sm\" style=\"margin-left: 8px;\">Search:</label>\n        <input id=\"error-log-search\" type=\"search\" placeholder=\"message / stack / ip\" style=\"padding: 5px 8px; border-radius: 6px; border: 1px solid var(--border); background: var(--bg); color: var(--fg); font-size: 0.82rem; min-width: 180px;\">\n        <label class=\"text-muted-sm\" style=\"margin-left: 8px;\">Since:</label>\n        <input id=\"error-log-since\" type=\"datetime-local\" style=\"padding: 5px 8px; border-radius: 6px; border: 1px solid var(--border); background: var(--bg); color: var(--fg); font-size: 0.82rem;\">\n        <label class=\"text-muted-sm\">Until:</label>\n        <input id=\"error-log-until\" type=\"datetime-local\" style=\"padding: 5px 8px; border-radius: 6px; border: 1px solid var(--border); background: var(--bg); color: var(--fg); font-size: 0.82rem;\">\n        <button id=\"error-log-refresh\" class=\"btn-sm\">\uD83D\uDD04 Refresh</button>\n        <span style=\"flex: 1;\"></span>\n        <button id=\"error-log-clear\" style=\"padding: 6px 12px; font-size: 0.8rem; color: var(--bad-fg); border-color: var(--bad-fg);\">\uD83D\uDDD1\uFE0F Clear Log</button>\n      </div>\n\n      <div id=\"error-log-container\" class=\"scroll-container\">\n        <div class=\"panel-empty\"><span class=\"brand-spinner\"></span> Loading error logs...</div>\n      </div>\n\n      <div style=\"margin-top: 12px; text-align: center;\">\n        <button id=\"error-log-load-more\" style=\"display: none; padding: 6px 16px; font-size: 0.8rem;\">Load More</button>\n      </div>\n\n      <div style=\"margin-top: 8px; font-size: 0.78rem; color: var(--muted); text-align: right;\">\n        <span id=\"error-log-total\"></span>\n      </div>\n\n      <div class=\"weather-modal-buttons modal-footer-bar\">\n        <button id=\"error-log-close\">Close</button>\n      </div>\n    </div>\n  </div>`);\n\n  const modal = document.getElementById('error-log-modal');\n  const viewBtn = document.getElementById('view-error-logs');\n  const refreshBtn = document.getElementById('error-log-refresh');\n  const clearBtn = document.getElementById('error-log-clear');\n  const closeBtn = document.getElementById('error-log-close');\n  const levelSel = document.getElementById('error-log-level');\n  const contextSel = document.getElementById('error-log-context');\n  const searchInput = document.getElementById('error-log-search');\n  const sinceInput = document.getElementById('error-log-since');\n  const untilInput = document.getElementById('error-log-until');\n  const container = document.getElementById('error-log-container');\n  const loadMoreBtn = document.getElementById('error-log-load-more');\n  const totalSpan = document.getElementById('error-log-total');\n\n  const PAGE_SIZE = 50;\n  let currentOffset = 0;\n  let inflight = null;\n  let filterNonce = 0;\n  // Cached distinct contexts so the dropdown is populated once per open and\n  // re-populated after a clear (which removes all contexts) or a refresh\n  // that surfaces a new subsystem for the first time.\n  let knownContexts = [];\n\n  // datetime-local fields are naive local time \u2014 convert to UTC ISO so the\n  // server compares correctly. Same shape as audit-log.js so the operator\n  // sees consistent behaviour between the two modals.\n  function toIso(localDtValue) {\n    if (!localDtValue) return null;\n    const d = new Date(localDtValue);\n    if (isNaN(d.getTime())) return null;\n    return d.toISOString();\n  }\n\n  // Pull the distinct contexts list once per open. Failures are silent\n  // (the dropdown will just show \"All\" only) so a transient backend hiccup\n  // doesn't block the operator from seeing the actual error rows.\n  async function refreshContexts() {\n    try {\n      const res = await fetch('/api/v1/error-logs/contexts');\n      if (!res.ok) return;\n      const data = await res.json();\n      if (!data.success || !Array.isArray(data.contexts)) return;\n      knownContexts = data.contexts;\n      const currentValue = contextSel.value;\n      contextSel.innerHTML = '<option value=\"\">All</option>';\n      for (const c of data.contexts) {\n        const opt = document.createElement('option');\n        opt.value = c.name;\n        opt.textContent = `${c.name} (${c.count})`;\n        contextSel.appendChild(opt);\n      }\n      // Restore previous selection if still present.\n      if (currentValue && data.contexts.some((c) => c.name === currentValue)) {\n        contextSel.value = currentValue;\n      }\n    } catch { /* ignore */ }\n  }\n\n  function buildQuery() {\n    const params = new URLSearchParams();\n    params.set('limit', String(PAGE_SIZE));\n    params.set('offset', String(currentOffset));\n    if (levelSel.value) params.set('level', levelSel.value);\n    if (contextSel.value) params.set('context', contextSel.value);\n    const since = toIso(sinceInput.value);\n    const until = toIso(untilInput.value);\n    if (since) params.set('since', since);\n    if (until) params.set('until', until);\n    const search = (searchInput.value || '').trim();\n    if (search) params.set('search', search);\n    return params;\n  }\n\n  async function loadLogs(append) {\n    try {\n      if (!append) {\n        if (inflight) inflight.abort();\n        inflight = new AbortController();\n        currentOffset = 0;\n        filterNonce++;\n        container.innerHTML = '<div class=\"panel-empty\"><span class=\"brand-spinner\"></span> Loading...</div>';\n      } else {\n        if (inflight) inflight.abort();\n        inflight = new AbortController();\n      }\n      const myNonce = filterNonce;\n      const params = buildQuery();\n\n      const res = await fetch('/api/v1/error-logs?' + params.toString(), {\n        signal: inflight.signal,\n      });\n      // Mirror audit-log: surface 4xx/5xx explicitly instead of falling\n      // through to a misleading \"no entries yet\" empty state.\n      if (!res.ok) {\n        container.innerHTML = `<div class=\"panel-empty\" style=\"color: var(--bad-fg);\">Failed: HTTP ${res.status}</div>`;\n        loadMoreBtn.style.display = 'none';\n        totalSpan.textContent = '';\n        return;\n      }\n      const data = await res.json();\n      if (!data.success) {\n        container.innerHTML = `<div class=\"panel-empty\" style=\"color: var(--bad-fg);\">Failed: ${escapeHtml(data.error || 'unknown')}</div>`;\n        loadMoreBtn.style.display = 'none';\n        totalSpan.textContent = '';\n        return;\n      }\n      // Stale-response guard: a non-append load happened after this fetch,\n      // discard so we don't splice into the wrong DOM.\n      if (!append && myNonce !== filterNonce) return;\n\n      const logs = Array.isArray(data.logs) ? data.logs : [];\n      if (logs.length === 0 && !append) {\n        const reason = (data.filters && (data.filters.level || data.filters.context || data.filters.search || data.filters.since || data.filters.until))\n          ? 'No error log entries match your filters.'\n          : '\u2705 No errors logged! Everything is working smoothly.';\n        container.innerHTML = `<div class=\"panel-empty\"><span class=\"empty-icon\">\uD83D\uDCCB</span>${escapeHtml(reason)}</div>`;\n        loadMoreBtn.style.display = 'none';\n        totalSpan.textContent = data.total ? `${data.total} total` : '';\n        return;\n      }\n\n      let html = '';\n      if (!append) {\n        html = '<table style=\"width: 100%; border-collapse: collapse; font-size: 0.82rem;\">';\n        html += '<tr style=\"border-bottom: 1px solid var(--border); color: var(--muted);\">';\n        html += '<th style=\"padding: 6px; text-align: left; width: 160px;\">When</th>';\n        html += '<th style=\"padding: 6px; text-align: left; width: 80px;\">Level</th>';\n        html += '<th style=\"padding: 6px; text-align: left; width: 140px;\">Context</th>';\n        html += '<th style=\"padding: 6px; text-align: left;\">Message</th>';\n        html += '<th style=\"padding: 6px; text-align: left; width: 110px;\">IP</th>';\n        html += '</tr>';\n      }\n\n      for (const log of logs) {\n        const level = (log.level || '?').toUpperCase();\n        const levelColor = level === 'ERR' ? 'var(--bad-fg)' : (level === 'WARN' ? 'var(--warn-fg, #f0c674)' : 'var(--muted)');\n        const ts = log.timestamp ? new Date(log.timestamp).toLocaleString() : '\u2014';\n        const ctx = log.context || '\u2014';\n        const msg = (log.error || '').split('\\n')[0];\n        const ip = (log.request && log.request.ip) || '';\n        html += `<tr style=\"border-bottom: 1px solid var(--border); cursor: pointer;\" class=\"error-log-row\">`;\n        html += `<td style=\"padding: 6px; color: var(--muted);\" title=\"${escapeHtml(log.timestamp || '')}\">${escapeHtml(ts)}</td>`;\n        html += `<td style=\"padding: 6px;\"><span style=\"color: ${levelColor}; font-weight: 600;\">${escapeHtml(level)}</span></td>`;\n        html += `<td style=\"padding: 6px; font-family: monospace; font-size: 0.78rem;\">${escapeHtml(ctx)}</td>`;\n        html += `<td style=\"padding: 6px;\">${escapeHtml(msg)}</td>`;\n        html += `<td style=\"padding: 6px; font-family: monospace; font-size: 0.78rem;\">${escapeHtml(ip)}</td>`;\n        html += '</tr>';\n        if (log.detail) {\n          html += `<tr class=\"error-log-detail\" style=\"display: none;\"><td colspan=\"5\" style=\"padding: 6px 6px 10px; font-size: 0.78rem; color: var(--muted);\"><pre style=\"margin: 0; white-space: pre-wrap; font-family: monospace; max-height: 320px; overflow: auto;\">${escapeHtml(log.detail)}</pre></td></tr>`;\n        }\n      }\n\n      if (!append) {\n        html += '</table>';\n        container.innerHTML = html;\n      } else {\n        const table = container.querySelector('table');\n        if (table) table.insertAdjacentHTML('beforeend', html);\n      }\n\n      currentOffset += logs.length;\n      loadMoreBtn.style.display = data.hasMore ? '' : 'none';\n      totalSpan.textContent = `${data.total} total${data.hasMore ? ' (showing ' + currentOffset + ')' : ''}`;\n\n      // Toggle detail rows on click \u2014 same pattern as audit-log.js\n      container.querySelectorAll('.error-log-row').forEach((row) => {\n        if (row.dataset.wired) return;\n        row.dataset.wired = 'true';\n        row.addEventListener('click', () => {\n          const detail = row.nextElementSibling;\n          if (detail && detail.classList.contains('error-log-detail')) {\n            detail.style.display = detail.style.display === 'none' ? '' : 'none';\n          }\n        });\n      });\n    } catch (e) {\n      if (e && e.name === 'AbortError') return;\n      container.innerHTML = `<div class=\"panel-empty\" style=\"color: var(--bad-fg);\">Failed: ${escapeHtml(e.message)}</div>`;\n      totalSpan.textContent = '';\n    }\n  }\n\n  async function clearLogs() {\n    if (!confirm('Clear the entire error log? This cannot be undone.')) return;\n    try {\n      const res = await secureFetch('/api/v1/error-logs', {\n        method: 'DELETE',\n        headers: { 'content-type': 'application/json' },\n        body: JSON.stringify({ confirm: 'CLEAR' }),\n      });\n      const data = await res.json();\n      if (data.success) {\n        // After a clear, the contexts list will be empty \u2014 re-fetch so the\n        // dropdown reflects reality. Load the now-empty page in parallel.\n        await refreshContexts();\n        loadLogs(false);\n        showNotification('\u2705 Error logs cleared', 'success', 3000);\n      } else {\n        showNotification('\u274C ' + (data.error || 'Clear failed'), 'error', 4000);\n      }\n    } catch (e) {\n      showNotification('\u274C ' + e.message, 'error', 4000);\n    }\n  }\n\n  // Debounce text-input changes so we don't refetch on every keystroke.\n  let searchDebounce;\n  function wireFilters() {\n    levelSel?.addEventListener('change', () => loadLogs(false));\n    contextSel?.addEventListener('change', () => loadLogs(false));\n    searchInput?.addEventListener('input', () => {\n      clearTimeout(searchDebounce);\n      searchDebounce = setTimeout(() => loadLogs(false), 250);\n    });\n    let dateDebounce;\n    [sinceInput, untilInput].forEach((el) => {\n      el?.addEventListener('change', () => {\n        clearTimeout(dateDebounce);\n        dateDebounce = setTimeout(() => loadLogs(false), 250);\n      });\n    });\n    refreshBtn?.addEventListener('click', () => loadLogs(false));\n    loadMoreBtn?.addEventListener('click', () => loadLogs(true));\n    clearBtn?.addEventListener('click', clearLogs);\n    wireModal(modal, closeBtn);\n  }\n\n  viewBtn?.addEventListener('click', async () => {\n    modal?.classList.add('show');\n    await refreshContexts();\n    loadLogs(false);\n  });\n  wireFilters();\n})();\n;\n// ========== CONTAINER LOG VIEWER ==========\n(function() {\n  // Inject modal HTML\n  injectModal('container-logs-modal', `<div id=\"container-logs-modal\" class=\"weather-modal\" style=\"z-index: 1001;\">\n    <div class=\"weather-modal-content\" style=\"min-width: 900px; max-width: 95vw; height: 80vh; display: flex; flex-direction: column;\">\n      <div class=\"logs-header\" style=\"display: flex; justify-content: space-between; align-items: center; padding-bottom: 12px; border-bottom: 1px solid var(--border); margin-bottom: 12px;\">\n        <div>\n          <h3 style=\"margin: 0;\">\uD83D\uDCDC Container Logs</h3>\n          <p class=\"modal-subtitle\" style=\"margin: 4px 0 0 0; font-size: 0.85rem; opacity: 0.7;\">View and stream Docker container logs</p>\n        </div>\n        <div class=\"logs-controls\" style=\"display: flex; gap: 8px; align-items: center;\">\n          <select id=\"cl-container-select\" style=\"padding: 6px 10px; border: 1px solid var(--border); border-radius: 6px; background: var(--bg); color: var(--fg); min-width: 200px;\">\n            <option value=\"\">Select a container...</option>\n          </select>\n          <input type=\"text\" id=\"cl-log-search\" placeholder=\"Search logs...\" style=\"padding: 6px 10px; border: 1px solid var(--border); border-radius: 6px; background: var(--bg); color: var(--fg); width: 150px;\" />\n          <select id=\"cl-log-tail\" style=\"padding: 6px 10px; border: 1px solid var(--border); border-radius: 6px; background: var(--bg); color: var(--fg);\">\n            <option value=\"50\">Last 50 lines</option>\n            <option value=\"100\" selected>Last 100 lines</option>\n            <option value=\"500\">Last 500 lines</option>\n            <option value=\"1000\">Last 1000 lines</option>\n            <option value=\"all\">All logs</option>\n          </select>\n          <button id=\"cl-refresh\" class=\"btn-accent-solid\" style=\"padding: 6px 14px; font-size: 0.85rem;\">\uD83D\uDD04 Refresh</button>\n          <button id=\"cl-stream\" class=\"btn-accent-solid\" style=\"padding: 6px 14px; font-size: 0.85rem;\">\u25B6 Stream</button>\n          <button id=\"cl-download\" style=\"padding: 6px 14px; font-size: 0.85rem;\">\uD83D\uDCBE Download</button>\n          <button id=\"cl-clear-search\" style=\"padding: 6px 10px; font-size: 0.85rem;\" title=\"Clear search\">\u2715</button>\n          <button id=\"cl-close\" class=\"close-btn\" style=\"padding: 6px 10px;\">\u2715</button>\n        </div>\n      </div>\n      \n      <div id=\"cl-container-info\" style=\"display: flex; gap: 16px; margin-bottom: 12px; padding: 8px 12px; background: var(--bg-secondary, var(--bg)); border-radius: 6px; font-size: 0.82rem;\">\n        <span><strong>Image:</strong> <span id=\"cl-image\">-</span></span>\n        <span><strong>Status:</strong> <span id=\"cl-status\">-</span></span>\n        <span><strong>Created:</strong> <span id=\"cl-created\">-</span></span>\n      </div>\n      \n      <div id=\"cl-log-content\" class=\"logs-content scroll-container\" style=\"flex: 1; min-height: 0; background: #1a1a1a; border-radius: 6px; padding: 12px; font-family: 'Monaco', 'Menlo', 'Ubuntu Mono', monospace; font-size: 0.78rem; overflow: auto;\">\n        <div class=\"logs-loading\" style=\"color: var(--muted); text-align: center; padding: 40px;\">Select a container to view logs</div>\n      </div>\n      \n      <div id=\"cl-stream-status\" style=\"display: none; padding: 8px 12px; background: var(--ok-bg, #1a3a1a); color: var(--ok-fg, #4ade80); border-radius: 6px; margin-top: 8px; font-size: 0.82rem;\">\n        <span id=\"cl-stream-indicator\">\uD83D\uDD34</span> <span id=\"cl-stream-text\">Disconnected</span>\n      </div>\n      \n      <div class=\"weather-modal-buttons modal-footer-bar\" style=\"margin-top: 12px; padding-top: 12px; border-top: 1px solid var(--border);\">\n        <div style=\"display: flex; gap: 8px; font-size: 0.78rem; color: var(--muted);\">\n          <span id=\"cl-line-count\">0 lines</span>\n          <span>|</span>\n          <span id=\"cl-filter-count\">0 filtered</span>\n        </div>\n        <button id=\"cl-close-btn\" class=\"btn-secondary\">Close</button>\n      </div>\n    </div>\n  </div>`);\n\n  const modal = document.getElementById('container-logs-modal');\n  const containerSelect = document.getElementById('cl-container-select');\n  const logContent = document.getElementById('cl-log-content');\n  const logSearch = document.getElementById('cl-log-search');\n  const logTail = document.getElementById('cl-log-tail');\n  const refreshBtn = document.getElementById('cl-refresh');\n  const streamBtn = document.getElementById('cl-stream');\n  const downloadBtn = document.getElementById('cl-download');\n  const clearSearchBtn = document.getElementById('cl-clear-search');\n  const closeBtn = document.getElementById('cl-close');\n  const closeBtn2 = document.getElementById('cl-close-btn');\n  const streamStatus = document.getElementById('cl-stream-status');\n  const streamIndicator = document.getElementById('cl-stream-indicator');\n  const streamText = document.getElementById('cl-stream-text');\n  const lineCount = document.getElementById('cl-line-count');\n  const filterCount = document.getElementById('cl-filter-count');\n  \n  // Container info elements\n  const imageEl = document.getElementById('cl-image');\n  const statusEl = document.getElementById('cl-status');\n  const createdEl = document.getElementById('cl-created');\n\n  let currentContainerId = null;\n  let currentLogs = [];\n  let filteredLogs = [];\n  let eventSource = null;\n  let isStreaming = false;\n  let searchTimeout = null;\n\n  // Format date\n  function formatDate(dateStr) {\n    if (!dateStr) return '-';\n    const d = new Date(dateStr);\n    if (isNaN(d.getTime())) return dateStr;\n    return d.toLocaleString();\n  }\n\n  // Escape HTML\n  function escapeHtml(str) {\n    if (!str) return '';\n    const div = document.createElement('div');\n    div.textContent = str;\n    return div.innerHTML;\n  }\n\n  // Format log entry for display\n  function formatLogEntry(log, index) {\n    const streamClass = log.stream === 'stderr' ? 'log-stderr' : 'log-stdout';\n    const streamIcon = log.stream === 'stderr' ? '\u26A0\uFE0F' : '\uD83D\uDCE4';\n    return `\n      <div class=\"log-entry ${streamClass}\" data-index=\"${index}\" style=\"padding: 4px 8px; border-bottom: 1px solid #333; display: flex; gap: 8px;\">\n        <span class=\"log-line-num\" style=\"color: #666; min-width: 40px; text-align: right; user-select: none;\">${index + 1}</span>\n        <span class=\"log-stream-icon\" style=\"color: ${log.stream === 'stderr' ? '#f59e0b' : '#22c55e'};\">${streamIcon}</span>\n        <span class=\"log-text\" style=\"flex: 1; white-space: pre-wrap; word-break: break-all; color: #e5e5e5;\">${escapeHtml(log.text)}</span>\n      </div>\n    `;\n  }\n\n  // Render logs to the content area\n  function renderLogs(logs, searchTerm = '') {\n    if (!logs || logs.length === 0) {\n      logContent.innerHTML = '<div class=\"logs-loading\" style=\"color: var(--muted); text-align: center; padding: 40px;\">No logs available</div>';\n      lineCount.textContent = '0 lines';\n      filterCount.textContent = '0 filtered';\n      return;\n    }\n\n    currentLogs = logs;\n    filteredLogs = searchTerm ? logs.filter(log => \n      log.text && log.text.toLowerCase().includes(searchTerm.toLowerCase())\n    ) : logs;\n\n    lineCount.textContent = `${logs.length} lines`;\n    filterCount.textContent = searchTerm ? `${filteredLogs.length} of ${logs.length} shown` : `${logs.length} shown`;\n\n    if (filteredLogs.length === 0) {\n      logContent.innerHTML = `<div class=\"logs-loading\" style=\"color: var(--muted); text-align: center; padding: 40px;\">No logs match \"${escapeHtml(searchTerm)}\"</div>`;\n      return;\n    }\n\n    logContent.innerHTML = filteredLogs.map((log, i) => formatLogEntry(log, i)).join('');\n    \n    // Scroll to bottom\n    logContent.scrollTop = logContent.scrollHeight;\n  }\n\n  // Load container list\n  async function loadContainers() {\n    try {\n      const data = await getJSON('/api/v1/logs/containers');\n      const containers = data.containers || [];\n      \n      // Store current selection\n      const currentVal = containerSelect.value;\n      \n      containerSelect.innerHTML = '<option value=\"\">Select a container...</option>';\n      \n      containers.forEach(c => {\n        const option = document.createElement('option');\n        option.value = c.id;\n        option.textContent = `${c.name} (${c.image.split(':')[0]}) - ${c.status}`;\n        option.dataset.name = c.name;\n        option.dataset.image = c.image;\n        option.dataset.status = c.status;\n        option.dataset.created = c.created;\n        containerSelect.appendChild(option);\n      });\n      \n      // Restore selection if still valid\n      if (currentVal && containerSelect.querySelector(`option[value=\"${currentVal}\"]`)) {\n        containerSelect.value = currentVal;\n        loadContainerInfo(currentVal);\n      }\n    } catch (err) {\n      console.error('Failed to load containers:', err);\n    }\n  }\n\n  // Load container info\n  function loadContainerInfo(containerId) {\n    const option = containerSelect.querySelector(`option[value=\"${containerId}\"]`);\n    if (option) {\n      imageEl.textContent = option.dataset.image || '-';\n      statusEl.textContent = option.dataset.status || '-';\n      statusEl.style.color = option.dataset.status === 'running' ? 'var(--ok-fg, #4ade80)' : 'var(--bad-fg, #ef4444)';\n      createdEl.textContent = formatDate(option.dataset.created);\n    }\n  }\n\n  // Load logs for selected container\n  async function loadLogs() {\n    const containerId = containerSelect.value;\n    if (!containerId) {\n      logContent.innerHTML = '<div class=\"logs-loading\" style=\"color: var(--muted); text-align: center; padding: 40px;\">Select a container to view logs</div>';\n      return;\n    }\n\n    // Stop any existing stream\n    stopStream();\n\n    currentContainerId = containerId;\n    loadContainerInfo(containerId);\n\n    const tail = logTail.value;\n    const searchTerm = logSearch.value.trim();\n\n    logContent.innerHTML = '<div class=\"logs-loading\" style=\"color: var(--muted); text-align: center; padding: 40px;\">Loading logs...</div>';\n\n    try {\n      const url = `/api/v1/logs/container/${containerId}${tail !== 'all' ? `?tail=${tail}` : ''}`;\n      const data = await getJSON(url);\n\n      if (data.logs && data.logs.length > 0) {\n        renderLogs(data.logs, searchTerm);\n      } else {\n        logContent.innerHTML = '<div class=\"logs-loading\" style=\"color: var(--muted); text-align: center; padding: 40px;\">No logs found for this container</div>';\n        lineCount.textContent = '0 lines';\n        filterCount.textContent = '0 filtered';\n      }\n    } catch (err) {\n      logContent.innerHTML = `<div class=\"logs-loading\" style=\"color: var(--bad-fg, #ef4444); text-align: center; padding: 40px;\">Error loading logs: ${escapeHtml(err.message)}</div>`;\n    }\n  }\n\n  // Start streaming logs\n  function startStream() {\n    const containerId = containerSelect.value;\n    if (!containerId) return;\n\n    // Stop any existing stream\n    stopStream();\n\n    isStreaming = true;\n    streamBtn.textContent = '\u23F9 Stop';\n    streamStatus.style.display = 'flex';\n    streamIndicator.textContent = '\uD83D\uDFE2';\n    streamText.textContent = 'Connecting...';\n\n    const url = `/api/v1/logs/stream/${containerId}`;\n    eventSource = new EventSource(url);\n\n    eventSource.onopen = () => {\n      streamIndicator.textContent = '\uD83D\uDFE2';\n      streamText.textContent = 'Connected - streaming logs';\n    };\n\n    eventSource.onmessage = (event) => {\n      try {\n        const log = JSON.parse(event.data);\n        \n        if (log.error) {\n          streamIndicator.textContent = '\uD83D\uDD34';\n          streamText.textContent = `Error: ${log.error}`;\n          return;\n        }\n\n        // Add to current logs\n        currentLogs.push(log);\n        filteredLogs.push(log);\n        \n        // Update counts\n        lineCount.textContent = `${currentLogs.length} lines`;\n        filterCount.textContent = `${filteredLogs.length} shown`;\n        \n        // Append new log entry\n        const searchTerm = logSearch.value.trim();\n        if (!searchTerm || (log.text && log.text.toLowerCase().includes(searchTerm.toLowerCase()))) {\n          const entry = document.createElement('div');\n          entry.innerHTML = formatLogEntry(log, filteredLogs.length - 1);\n          const entryDiv = entry.firstElementChild;\n          entryDiv.style.background = '#1a3a1a';\n          logContent.appendChild(entryDiv);\n          \n          // Auto-scroll to bottom\n          logContent.scrollTop = logContent.scrollHeight;\n        }\n      } catch (e) {\n        console.error('Error parsing log:', e);\n      }\n    };\n\n    eventSource.onerror = () => {\n      streamIndicator.textContent = '\uD83D\uDD34';\n      streamText.textContent = 'Disconnected';\n      isStreaming = false;\n      streamBtn.textContent = '\u25B6 Stream';\n    };\n\n    // Store the EventSource for cleanup\n    modal._eventSource = eventSource;\n  }\n\n  // Stop streaming logs\n  function stopStream() {\n    if (eventSource) {\n      eventSource.close();\n      eventSource = null;\n    }\n    if (modal._eventSource) {\n      modal._eventSource.close();\n      modal._eventSource = null;\n    }\n    isStreaming = false;\n    streamBtn.textContent = '\u25B6 Stream';\n    streamStatus.style.display = 'none';\n  }\n\n  // Download logs as file\n  function downloadLogs() {\n    if (!currentLogs || currentLogs.length === 0) {\n      showNotification('No logs to download', 'error');\n      return;\n    }\n\n    const containerName = containerSelect.querySelector(`option[value=\"${currentContainerId}\"]`)?.dataset.name || currentContainerId;\n    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');\n    const filename = `${containerName}-logs-${timestamp}.txt`;\n\n    const content = currentLogs.map(log => {\n      const timestamp = log.timestamp || '';\n      const stream = log.stream === 'stderr' ? '[ERR]' : '[OUT]';\n      return `${timestamp ? timestamp + ' ' : ''}${stream} ${log.text}`;\n    }).join('\\n');\n\n    const blob = new Blob([content], { type: 'text/plain' });\n    const url = URL.createObjectURL(blob);\n    const a = document.createElement('a');\n    a.href = url;\n    a.download = filename;\n    document.body.appendChild(a);\n    a.click();\n    document.body.removeChild(a);\n    URL.revokeObjectURL(url);\n\n    showNotification(`Downloaded ${currentLogs.length} log lines`, 'success');\n  }\n\n  // Event listeners\n  containerSelect?.addEventListener('change', () => {\n    loadLogs();\n  });\n\n  logTail?.addEventListener('change', () => {\n    loadLogs();\n  });\n\n  refreshBtn?.addEventListener('click', () => {\n    loadLogs();\n  });\n\n  streamBtn?.addEventListener('click', () => {\n    if (isStreaming) {\n      stopStream();\n    } else {\n      startStream();\n    }\n  });\n\n  downloadBtn?.addEventListener('click', () => {\n    downloadLogs();\n  });\n\n  clearSearchBtn?.addEventListener('click', () => {\n    logSearch.value = '';\n    renderLogs(currentLogs, '');\n  });\n\n  logSearch?.addEventListener('input', () => {\n    // Debounce search\n    clearTimeout(searchTimeout);\n    searchTimeout = setTimeout(() => {\n      renderLogs(currentLogs, logSearch.value.trim());\n    }, 300);\n  });\n\n  logSearch?.addEventListener('keydown', (e) => {\n    if (e.key === 'Escape') {\n      logSearch.value = '';\n      renderLogs(currentLogs, '');\n    }\n  });\n\n  // Open modal\n  const openBtn = document.getElementById('view-container-logs');\n  openBtn?.addEventListener('click', () => {\n    modal.classList.add('show');\n    loadContainers();\n  });\n\n  // Close modal handlers\n  function closeModal() {\n    stopStream();\n    modal.classList.remove('show');\n  }\n\n  closeBtn?.addEventListener('click', closeModal);\n  closeBtn2?.addEventListener('click', closeModal);\n\n  // Close on escape key\n  document.addEventListener('keydown', (e) => {\n    if (e.key === 'Escape' && modal.classList.contains('show')) {\n      closeModal();\n    }\n  });\n\n  // Wire backdrop click to closeModal so the log stream stops too.\n  // (Can't use wireModal here \u2014 it only does modal.classList.remove('show')\n  // on backdrop click, which would leak the SSE/stream connection.)\n  modal.addEventListener('click', (e) => { if (e.target === modal) closeModal(); });\n\n  // Expose for use by service card buttons (grid.js calls openContainerLogsModal)\n  window.openContainerLogsModal = function(containerId, containerName) {\n    modal.classList.add('show');\n    loadContainers().then(() => {\n      // Try to find and select the container\n      const option = Array.from(containerSelect.options).find(opt => \n        opt.value === containerId || opt.dataset.name === containerName\n      );\n      if (option) {\n        containerSelect.value = option.value;\n        loadContainerInfo(option.value);\n        loadLogs();\n      } else if (containerId) {\n        // If container not found in list but we have an ID, try loading directly\n        currentContainerId = containerId;\n        imageEl.textContent = containerName || containerId;\n        statusEl.textContent = '-';\n        createdEl.textContent = '-';\n        loadLogs();\n      } else {\n        // No container ID, just show modal with container list\n        logContent.innerHTML = '<div class=\"logs-loading\" style=\"color: var(--muted); text-align: center; padding: 40px;\">Select a container to view logs</div>';\n      }\n    });\n  };\n})();\n;\n// ========== DC-055: HOST JOURNALD LOG VIEWER ==========\n// Streams host service logs (caddy, dashcaddy-api, docker, ssh, \u2026) via the\n// journalctl bind-mount added in start.sh. Server-Sent Events for live\n// tailing; bounded non-streaming read for historical views.\n(function() {\n  'use strict';\n\n  // Allow-list mirrors the backend's ALLOWED_UNITS so the dropdown stays\n  // honest when the bind-mount isn't available. The server is still the\n  // source of truth \u2014 anything not in its allow-list returns 400.\n  const UNIT_PRESETS = [\n    { unit: 'caddy',          label: 'Caddy (reverse proxy)' },\n    { unit: 'dashcaddy-api',  label: 'DashCaddy API (host systemd unit, not this container)' },\n    { unit: 'docker',         label: 'Docker daemon' },\n    { unit: 'ssh',            label: 'SSH server' },\n    { unit: 'systemd-journald', label: 'systemd-journald' },\n    { unit: 'tailscaled',     label: 'Tailscale' },\n    { unit: 'networkd-dispatcher', label: 'Networkd dispatcher' },\n  ];\n\n  injectModal('journald-modal', `\n    <div id=\"journald-modal\" class=\"weather-modal\" style=\"z-index: 1002;\">\n      <div class=\"weather-modal-content\" style=\"min-width: 900px; max-width: 95vw; height: 80vh; display: flex; flex-direction: column;\">\n        <div class=\"logs-header\" style=\"display: flex; justify-content: space-between; align-items: center; padding-bottom: 12px; border-bottom: 1px solid var(--border); margin-bottom: 12px;\">\n          <div>\n            <h3 style=\"margin: 0;\">\uD83D\uDEF0\uFE0F Host Logs (journald)</h3>\n            <p class=\"modal-subtitle\" style=\"margin: 4px 0 0 0; font-size: 0.85rem; opacity: 0.7;\">\n              Stream host service logs from <code>journalctl</code> (read-only mount). Docker container logs are still in the <em>Container Logs</em> modal.\n            </p>\n          </div>\n          <div class=\"logs-controls\" style=\"display: flex; gap: 8px; align-items: center; flex-wrap: wrap; justify-content: flex-end;\">\n            <select id=\"jd-unit-select\" style=\"padding: 6px 10px; border: 1px solid var(--border); border-radius: 6px; background: var(--bg); color: var(--fg); min-width: 220px;\"></select>\n            <input type=\"text\" id=\"jd-search\" placeholder=\"Search logs...\" style=\"padding: 6px 10px; border: 1px solid var(--border); border-radius: 6px; background: var(--bg); color: var(--fg); width: 160px;\" />\n            <input type=\"number\" id=\"jd-tail\" min=\"1\" max=\"5000\" value=\"200\" title=\"Lines to load (historical view)\" style=\"padding: 6px 10px; border: 1px solid var(--border); border-radius: 6px; background: var(--bg); color: var(--fg); width: 90px;\" />\n            <button id=\"jd-refresh\" class=\"btn-accent-solid\" style=\"padding: 6px 14px; font-size: 0.85rem;\">\uD83D\uDD04 Load tail</button>\n            <button id=\"jd-stream\" class=\"btn-accent-solid\" style=\"padding: 6px 14px; font-size: 0.85rem;\">\u25B6 Stream</button>\n            <button id=\"jd-clear-search\" style=\"padding: 6px 10px; font-size: 0.85rem;\" title=\"Clear search\">\u2715</button>\n            <button id=\"jd-close\" class=\"close-btn\" style=\"padding: 6px 10px;\">\u2715</button>\n          </div>\n        </div>\n\n        <div id=\"jd-meta\" style=\"display: flex; gap: 16px; margin-bottom: 12px; padding: 8px 12px; background: var(--bg-secondary, var(--bg)); border-radius: 6px; font-size: 0.82rem; flex-wrap: wrap;\">\n          <span><strong>Source:</strong> <span id=\"jd-source\">journald</span></span>\n          <span><strong>Unit:</strong> <span id=\"jd-unit-display\">-</span></span>\n          <span><strong>Stream:</strong> <span id=\"jd-stream-state\">disconnected</span></span>\n        </div>\n\n        <div id=\"jd-content\" class=\"logs-content scroll-container\" style=\"flex: 1; min-height: 0; background: #1a1a1a; border-radius: 6px; padding: 12px; font-family: 'Monaco', 'Menlo', 'Ubuntu Mono', monospace; font-size: 0.78rem; overflow: auto;\">\n          <div class=\"logs-loading\" style=\"color: var(--muted); text-align: center; padding: 40px;\">Select a unit and click <em>Load tail</em> or <em>Stream</em>.</div>\n        </div>\n\n        <div class=\"weather-modal-buttons modal-footer-bar\" style=\"margin-top: 12px; padding-top: 12px; border-top: 1px solid var(--border);\">\n          <div style=\"display: flex; gap: 8px; font-size: 0.78rem; color: var(--muted);\">\n            <span id=\"jd-line-count\">0 lines</span>\n            <span>|</span>\n            <span id=\"jd-filter-count\">0 shown</span>\n            <span>|</span>\n            <span id=\"jd-overflow\" style=\"display: none; color: var(--warn-fg, #fbbf24);\">\u26A0 stream overflow \u2014 re-load with narrower window</span>\n          </div>\n          <button id=\"jd-close-btn\" class=\"btn-secondary\">Close</button>\n        </div>\n      </div>\n    </div>\n  `);\n\n  const modal        = document.getElementById('journald-modal');\n  const unitSelect   = document.getElementById('jd-unit-select');\n  const searchInput  = document.getElementById('jd-search');\n  const tailInput    = document.getElementById('jd-tail');\n  const refreshBtn   = document.getElementById('jd-refresh');\n  const streamBtn    = document.getElementById('jd-stream');\n  const clearSearch  = document.getElementById('jd-clear-search');\n  const closeBtn     = document.getElementById('jd-close');\n  const closeBtn2    = document.getElementById('jd-close-btn');\n  const content      = document.getElementById('jd-content');\n  const lineCount    = document.getElementById('jd-line-count');\n  const filterCount  = document.getElementById('jd-filter-count');\n  const overflowHint = document.getElementById('jd-overflow');\n  const unitDisplay  = document.getElementById('jd-unit-display');\n  const streamState  = document.getElementById('jd-stream-state');\n\n  let available = false;     // /var/log/journal mounted?\n  let lines = [];            // current buffer (array of {timestamp, unit, text})\n  let streaming = false;\n  let eventSource = null;\n  let searchTimer = null;\n\n  function escapeHtml(s) {\n    // Local re-declaration so we don't depend on a global; same semantics\n    // as the helper used by container-logs.js and error-logs.js.\n    const div = document.createElement('div');\n    div.textContent = String(s);\n    return div.innerHTML;\n  }\n\n  function setAvailable(isAvailable) {\n    available = isAvailable;\n    unitSelect.innerHTML = '';\n    UNIT_PRESETS.forEach(p => {\n      const opt = document.createElement('option');\n      opt.value = p.unit;\n      opt.textContent = p.label + ' (' + p.unit + ')';\n      unitSelect.appendChild(opt);\n    });\n    unitSelect.disabled = !isAvailable;\n    if (!isAvailable) {\n      content.innerHTML = '<div class=\"logs-loading\" style=\"color: var(--muted); text-align: center; padding: 40px;\">journald bind-mount not available in this container.<br/><small>Requires <code>/var/log/journal</code> + <code>/usr/bin/journalctl</code> mounted (start.sh).</small></div>';\n      refreshBtn.disabled = true;\n      streamBtn.disabled = true;\n    } else {\n      refreshBtn.disabled = false;\n      streamBtn.disabled = false;\n    }\n  }\n\n  async function probeAvailable() {\n    try {\n      const resp = await fetch('/api/v1/logs/journal/units');\n      if (!resp.ok) { setAvailable(false); return; }\n      const data = await resp.json();\n      setAvailable(!!data.available);\n    } catch (e) {\n      setAvailable(false);\n    }\n  }\n\n  function renderLines() {\n    const term = (searchInput.value || '').trim().toLowerCase();\n    const filtered = term ? lines.filter(l => (l.textContent || '').toLowerCase().includes(term)) : lines;\n    if (filtered.length === 0) {\n      content.innerHTML = '<div class=\"logs-loading\" style=\"color: var(--muted); text-align: center; padding: 40px;\">No entries' + (term ? ` matching &quot;${escapeHtml(term)}&quot;` : '') + '</div>';\n    } else {\n      const html = filtered.map(line => {\n        const ts = line.timestamp ? escapeHtml(line.timestamp) : '\u2014';\n        const t = escapeHtml(line.textContent);\n        return `<div class=\"jd-line\" style=\"padding: 1px 0; line-height: 1.4; color: #d4d4d4;\"><span style=\"color: var(--muted); margin-right: 8px;\">${ts}</span>${t}</div>`;\n      }).join('');\n      content.innerHTML = html;\n      // Auto-scroll only if user is already at the bottom (don't fight them).\n      const nearBottom = content.scrollHeight - content.scrollTop - content.clientHeight < 80;\n      if (nearBottom) content.scrollTop = content.scrollHeight;\n    }\n    lineCount.textContent = `${lines.length} entries`;\n    filterCount.textContent = term ? `${filtered.length} of ${lines.length} shown` : `${lines.length} shown`;\n  }\n\n  async function loadTail() {\n    if (!available) return;\n    stopStream();\n    const unit = unitSelect.value;\n    if (!unit) return;\n    const tail = Math.max(1, Math.min(5000, Number(tailInput.value) || 200));\n    const term = (searchInput.value || '').trim();\n    content.innerHTML = '<div class=\"logs-loading\" style=\"color: var(--muted); text-align: center; padding: 40px;\">Loading\u2026</div>';\n    try {\n      const url = new URL('/api/v1/logs/journal', window.location.origin);\n      url.searchParams.set('unit', unit);\n      url.searchParams.set('tail', String(tail));\n      if (term) url.searchParams.set('search', term);\n      const resp = await fetch(url.toString());\n      const data = await resp.json();\n      if (!resp.ok || !data.success) {\n        content.innerHTML = '<div class=\"logs-loading\" style=\"color: var(--bad-fg, #ef4444); text-align: center; padding: 40px;\">Failed: ' + escapeHtml((data && data.error) || ('HTTP ' + resp.status)) + '</div>';\n        return;\n      }\n      unitDisplay.textContent = unit;\n      lines = (data.entries || []).map(e => ({\n        timestamp: e.timestamp,\n        unit: e.unit,\n        textContent: e.text || '',\n      }));\n      overflowHint.style.display = 'none';\n      renderLines();\n    } catch (e) {\n      content.innerHTML = '<div class=\"logs-loading\" style=\"color: var(--bad-fg, #ef4444); text-align: center; padding: 40px;\">Error: ' + escapeHtml(e.message) + '</div>';\n    }\n  }\n\n  function startStream() {\n    if (!available) return;\n    stopStream();\n    const unit = unitSelect.value;\n    if (!unit) return;\n    const term = (searchInput.value || '').trim();\n    unitDisplay.textContent = unit;\n    streamBtn.textContent = '\u23F8 Stop';\n    streamBtn.classList.add('streaming');\n    streamState.textContent = 'streaming';\n    streamState.style.color = 'var(--ok-fg, #4ade80)';\n    lines = [];\n    renderLines();\n    overflowHint.style.display = 'none';\n    const url = new URL('/api/v1/logs/journal/stream', window.location.origin);\n    url.searchParams.set('unit', unit);\n    if (term) url.searchParams.set('search', term);\n    eventSource = new EventSource(url.toString());\n    eventSource.onmessage = (ev) => {\n      try {\n        const entry = JSON.parse(ev.data);\n        if (entry.error) {\n          // Overflow / validation / bind-mount errors\n          if (/stream (exceeded|line cap)/.test(entry.error)) {\n            overflowHint.style.display = '';\n            stopStream();\n          }\n          content.innerHTML += '<div class=\"jd-line\" style=\"color: var(--bad-fg, #ef4444); padding: 4px 0;\">\u26A0 ' + escapeHtml(entry.error) + '</div>';\n          content.scrollTop = content.scrollHeight;\n          return;\n        }\n        lines.push({\n          timestamp: entry.timestamp,\n          unit: entry.unit || unit,\n          textContent: entry.text || '',\n        });\n        // Hard cap to keep memory bounded if operator streams forever.\n        if (lines.length > 5000) {\n          lines = lines.slice(lines.length - 5000);\n          overflowHint.style.display = '';\n        }\n        renderLines();\n      } catch (_) {\n        // Ignore malformed events; the server is authoritative.\n      }\n    };\n    eventSource.onerror = () => {\n      // EventSource auto-reconnects; mark transient if we were expecting\n      // more, otherwise we closed it deliberately.\n      if (!streaming) return;\n    };\n    streaming = true;\n  }\n\n  function stopStream() {\n    streaming = false;\n    if (eventSource) {\n      try { eventSource.close(); } catch (_) { /* ignore */ }\n      eventSource = null;\n    }\n    streamBtn.textContent = '\u25B6 Stream';\n    streamBtn.classList.remove('streaming');\n    streamState.textContent = 'disconnected';\n    streamState.style.color = 'var(--muted)';\n  }\n\n  function close() {\n    stopStream();\n    modal.classList.remove('show');\n  }\n\n  // Wire events\n  refreshBtn.addEventListener('click', loadTail);\n  streamBtn.addEventListener('click', () => streaming ? stopStream() : startStream());\n  clearSearch.addEventListener('click', () => { searchInput.value = ''; renderLines(); });\n  searchInput.addEventListener('input', () => {\n    clearTimeout(searchTimer);\n    searchTimer = setTimeout(renderLines, 200);\n  });\n  searchInput.addEventListener('keydown', (e) => {\n    if (e.key === 'Escape') { searchInput.value = ''; renderLines(); }\n  });\n  closeBtn.addEventListener('click', close);\n  closeBtn2.addEventListener('click', close);\n  modal.addEventListener('click', (e) => { if (e.target === modal) close(); });\n  document.addEventListener('keydown', (e) => {\n    if (e.key === 'Escape' && modal.classList.contains('show')) close();\n  });\n  // Reload tail automatically when the unit dropdown changes (if we have\n  // data already \u2014 saves a click).\n  unitSelect.addEventListener('change', () => {\n    if (lines.length > 0) loadTail();\n  });\n\n  // Hook into the existing \"Container Logs\" modal button so operators get a\n  // separate entry point; mirror the openContainerLogsModal pattern.\n  function openJournaldModal() {\n    modal.classList.add('show');\n    probeAvailable();\n  }\n  window.openJournaldModal = openJournaldModal;\n\n  document.getElementById('view-journald-logs')?.addEventListener('click', openJournaldModal);\n})();;\n// ========== CONTAINER SNAPSHOT / CHECKPOINT ==========\n(function() {\n  // Inject modal HTML\n  injectModal('snapshot-modal', `<div id=\"snapshot-modal\" class=\"weather-modal\">\n    <div class=\"weather-modal-content\" style=\"min-width: 700px; max-width: 850px;\">\n      <h3>\uD83D\uDCBE Container Snapshots</h3>\n      <p class=\"modal-subtitle\">\n        Create and manage Docker container checkpoints for instant state recovery.\n      </p>\n\n      <div id=\"snapshot-container-select-wrapper\" style=\"margin-bottom: 16px;\">\n        <label style=\"font-size: 0.85rem; color: var(--muted);\">Select Container:</label>\n        <select id=\"snapshot-container-select\" style=\"width: 100%; padding: 8px 12px; margin-top: 4px; background: var(--bg); border: 1px solid var(--border); border-radius: 6px; color: var(--fg); font-size: 0.9rem;\">\n          <option value=\"\">-- Select a container --</option>\n        </select>\n      </div>\n\n      <div id=\"snapshot-details\" style=\"display: none; margin-bottom: 16px; padding: 12px; border: 1px solid var(--border); border-radius: 8px; background: var(--card-hover);\">\n        <div style=\"display: grid; grid-template-columns: 1fr 1fr; gap: 8px; font-size: 0.85rem;\">\n          <div><span style=\"color: var(--muted);\">Image:</span> <span id=\"snapshot-image\"></span></div>\n          <div><span style=\"color: var(--muted);\">Status:</span> <span id=\"snapshot-status\"></span></div>\n          <div><span style=\"color: var(--muted);\">Created:</span> <span id=\"snapshot-created\"></span></div>\n          <div><span style=\"color: var(--muted);\">Container ID:</span> <span id=\"snapshot-id\" style=\"font-family: monospace;\"></span></div>\n        </div>\n      </div>\n\n      <div class=\"panel-tabs\" style=\"margin-bottom: 12px;\">\n        <button class=\"panel-tab active\" data-panel=\"snapshot-create\">Create Snapshot</button>\n        <button class=\"panel-tab\" data-panel=\"snapshot-list\">Manage Snapshots</button>\n      </div>\n\n      <div id=\"snapshot-create\" class=\"panel-section active\">\n        <div style=\"margin-bottom: 12px;\">\n          <label style=\"font-size: 0.85rem; color: var(--muted);\">Snapshot Name:</label>\n          <input type=\"text\" id=\"snapshot-name\" placeholder=\"e.g., before-update-2024\" \n            style=\"width: 100%; padding: 8px 12px; margin-top: 4px; background: var(--bg); border: 1px solid var(--border); border-radius: 6px; color: var(--fg); font-size: 0.9rem; box-sizing: border-box;\" />\n        </div>\n        <div style=\"margin-bottom: 12px;\">\n          <label class=\"checkbox-label\" style=\"font-size: 0.85rem;\">\n            <input type=\"checkbox\" id=\"snapshot-leave-running\" checked />\n            Leave container running after checkpoint (resume without restart)\n          </label>\n        </div>\n        <button id=\"snapshot-create-btn\" class=\"btn-accent-solid\" style=\"width: 100%;\">\uD83D\uDCBE Create Snapshot</button>\n        <div id=\"snapshot-create-status\" style=\"margin-top: 12px; text-align: center; font-size: 0.85rem;\"></div>\n      </div>\n\n      <div id=\"snapshot-list\" class=\"panel-section\" style=\"display: none;\">\n        <div id=\"snapshot-list-container\" class=\"scroll-container\" style=\"max-height: 300px;\">\n          <div class=\"panel-empty\"><span class=\"empty-icon\">\uD83D\uDCBE</span>Select a container to view its snapshots</div>\n        </div>\n      </div>\n\n      <div class=\"weather-modal-buttons modal-footer-bar\">\n        <button id=\"snapshot-close\">Close</button>\n      </div>\n    </div>\n  </div>`);\n\n  const modal = document.getElementById('snapshot-modal');\n  const openBtn = document.getElementById('snapshot-btn');\n  const closeBtn = document.getElementById('snapshot-close');\n  const containerSelect = document.getElementById('snapshot-container-select');\n  const detailsDiv = document.getElementById('snapshot-details');\n  const createBtn = document.getElementById('snapshot-create-btn');\n  const createStatus = document.getElementById('snapshot-create-status');\n\n  let currentContainerId = null;\n\n  async function loadContainers() {\n    try {\n      const res = await fetch('/api/v1/containers');\n      const data = await res.json();\n      if (!data.success || !data.containers) return;\n      \n      containerSelect.innerHTML = '<option value=\"\">-- Select a container --</option>';\n      for (const c of data.containers) {\n        const opt = document.createElement('option');\n        opt.value = c.id;\n        opt.textContent = `${c.name || c.id} (${c.image || 'unknown'})`;\n        opt.dataset.name = c.name;\n        opt.dataset.image = c.image;\n        opt.dataset.status = c.status;\n        opt.dataset.created = c.created;\n        containerSelect.appendChild(opt);\n      }\n    } catch (e) {\n      console.error('Failed to load containers:', e);\n    }\n  }\n\n  function showContainerDetails(opt) {\n    if (!opt || !opt.value) {\n      detailsDiv.style.display = 'none';\n      currentContainerId = null;\n      return;\n    }\n    currentContainerId = opt.value;\n    document.getElementById('snapshot-image').textContent = opt.dataset.image || '-';\n    document.getElementById('snapshot-status').textContent = opt.dataset.status || '-';\n    document.getElementById('snapshot-created').textContent = opt.dataset.created ? new Date(opt.dataset.created * 1000).toLocaleString() : '-';\n    document.getElementById('snapshot-id').textContent = opt.value.substring(0, 12);\n    detailsDiv.style.display = '';\n  }\n\n  async function createSnapshot() {\n    if (!currentContainerId) {\n      createStatus.textContent = 'Please select a container first';\n      createStatus.style.color = 'var(--bad-fg)';\n      return;\n    }\n    const name = document.getElementById('snapshot-name').value.trim();\n    if (!name) {\n      createStatus.textContent = 'Please enter a snapshot name';\n      createStatus.style.color = 'var(--bad-fg)';\n      return;\n    }\n    const leaveRunning = document.getElementById('snapshot-leave-running').checked;\n    \n    createBtn.disabled = true;\n    createBtn.textContent = 'Creating...';\n    createStatus.textContent = '';\n    \n    try {\n      const res = await fetch(`/api/v1/containers/${encodeURIComponent(currentContainerId)}/checkpoint`, {\n        method: 'POST',\n        headers: { 'Content-Type': 'application/json' },\n        body: JSON.stringify({ name, leaveRunning })\n      });\n      const data = await res.json();\n      if (data.success) {\n        createStatus.textContent = `\u2713 Snapshot \"${name}\" created successfully`;\n        createStatus.style.color = 'var(--ok-fg)';\n        document.getElementById('snapshot-name').value = '';\n      } else {\n        createStatus.textContent = `\u2717 Failed: ${data.error || 'Unknown error'}`;\n        createStatus.style.color = 'var(--bad-fg)';\n      }\n    } catch (e) {\n      createStatus.textContent = `\u2717 Error: ${e.message}`;\n      createStatus.style.color = 'var(--bad-fg)';\n    } finally {\n      createBtn.disabled = false;\n      createBtn.textContent = '\uD83D\uDCBE Create Snapshot';\n    }\n  }\n\n  function openModal() {\n    modal.classList.add('show');\n    loadContainers();\n  }\n\n  function closeModal() {\n    modal.classList.remove('show');\n    detailsDiv.style.display = 'none';\n    currentContainerId = null;\n    containerSelect.selectedIndex = 0;\n  }\n\n  openBtn?.addEventListener('click', openModal);\n  closeBtn?.addEventListener('click', closeModal);\n  wireModal(modal, closeBtn);\n  \n  containerSelect?.addEventListener('change', (e) => {\n    const opt = containerSelect.options[containerSelect.selectedIndex];\n    showContainerDetails(opt);\n  });\n  \n  createBtn?.addEventListener('click', createSnapshot);\n  \n  // Tab switching\n  modal?.querySelectorAll('.panel-tab').forEach(tab => {\n    tab.addEventListener('click', () => {\n      modal.querySelectorAll('.panel-tab').forEach(t => t.classList.remove('active'));\n      modal.querySelectorAll('.panel-section').forEach(s => s.classList.remove('active'));\n      tab.classList.add('active');\n      modal.querySelector(`#${tab.dataset.panel}`).classList.add('active');\n    });\n  });\n})();\n;\n// ========== SMART ARR CONNECT ==========\n(function() {\n  injectModal('arr-setup-modal', `<div id=\"arr-setup-modal\" class=\"weather-modal\">\n    <div class=\"weather-modal-content\" style=\"min-width: 600px; max-width: 720px;\">\n      <h3>\uD83C\uDFAC Smart Arr Connect</h3>\n      <p style=\"color: var(--muted); margin: 0 0 16px; font-size: 0.9rem;\">\n        Auto-discover and connect your entire media stack.\n      </p>\n\n      <!-- Phase 1: Detection -->\n      <div id=\"smart-phase-detect\">\n        <div style=\"text-align: center; padding: 20px;\">\n          <span class=\"brand-spinner\" style=\"margin-bottom: 12px; display: inline-block;\"></span>\n          <div style=\"color: var(--muted); font-size: 0.9rem;\">Scanning for services...</div>\n        </div>\n        <div id=\"smart-detect-results\" style=\"display: none;\"></div>\n      </div>\n\n      <!-- Phase 2: Credential Input (only for services needing keys) -->\n      <div id=\"smart-phase-credentials\" style=\"display: none;\">\n        <h4 class=\"heading-accent-section\">Enter Missing API Keys</h4>\n        <div id=\"smart-credential-inputs\"></div>\n\n        <!-- Connection Options -->\n        <div style=\"margin-top: 16px; padding: 12px; background: var(--card-base); border-radius: 8px; border: 1px solid var(--border);\">\n          <h4 style=\"margin: 0 0 10px; font-size: 0.85rem; color: var(--accent);\">Connection Options</h4>\n          <label class=\"option-label\">\n            <input type=\"checkbox\" id=\"smart-opt-seerr\" checked class=\"checkbox-sm\" />\n            Configure Seerr with Radarr + Sonarr\n          </label>\n          <label class=\"option-label\">\n            <input type=\"checkbox\" id=\"smart-opt-plex\" checked class=\"checkbox-sm\" />\n            Connect Plex to Seerr\n          </label>\n          <label class=\"option-label\">\n            <input type=\"checkbox\" id=\"smart-opt-prowlarr\" checked class=\"checkbox-sm\" />\n            Connect Prowlarr to Radarr + Sonarr\n          </label>\n          <label style=\"display: flex; align-items: center; gap: 8px; cursor: pointer; font-size: 0.85rem;\">\n            <input type=\"checkbox\" id=\"smart-opt-save\" checked class=\"checkbox-sm\" />\n            Save API keys for one-click reconnect\n          </label>\n        </div>\n\n        <button id=\"smart-connect-btn\" style=\"width: 100%; margin-top: 16px; padding: 12px; background: linear-gradient(135deg, #e74c3c 0%, #9b59b6 100%); border: none; color: white; font-weight: 600; font-size: 1rem; border-radius: 8px; cursor: pointer;\">\n          Smart Connect\n        </button>\n      </div>\n\n      <!-- Phase 3: Connection Progress -->\n      <div id=\"smart-phase-progress\" style=\"display: none;\">\n        <h4 class=\"heading-accent-section\">Connecting Everything...</h4>\n        <div id=\"smart-progress-steps\" style=\"display: flex; flex-direction: column; gap: 6px;\"></div>\n      </div>\n\n      <!-- Phase 4: Results -->\n      <div id=\"smart-phase-results\" style=\"display: none;\">\n        <div id=\"smart-results-content\"></div>\n        <div id=\"smart-plex-libraries\" style=\"display: none; margin-top: 12px;\"></div>\n        <div style=\"display: flex; gap: 8px; margin-top: 16px;\">\n          <button id=\"smart-retry-btn\" style=\"display: none; flex: 1; padding: 10px; background: #f39c12; border: none; color: white; font-weight: 500; border-radius: 8px; cursor: pointer;\">\n            Retry Failed Steps\n          </button>\n          <a id=\"smart-open-seerr\" href=\"#\" target=\"_blank\" rel=\"noopener noreferrer\"\n             style=\"flex: 1; padding: 10px; background: var(--accent); color: white; border: none; border-radius: 8px; cursor: pointer; font-weight: 500; text-decoration: none; text-align: center;\">\n            Open Seerr\n          </a>\n        </div>\n      </div>\n\n      <!-- Help Text -->\n      <div style=\"font-size: 0.75rem; color: var(--muted); margin-top: 12px; padding: 10px; background: color-mix(in srgb, var(--accent) 5%, transparent); border-radius: 6px;\">\n        <strong>Where to find API keys:</strong><br>\n        Radarr/Sonarr/Prowlarr: Settings -> General -> Security -> API Key\n      </div>\n\n      <!-- Close Button -->\n      <div class=\"weather-modal-buttons modal-footer-bar\">\n        <button id=\"arr-setup-cancel\">Close</button>\n      </div>\n    </div>\n  </div>`);\n\n  const modal = document.getElementById('arr-setup-modal');\n  const openBtn = document.getElementById('arr-setup-btn');\n  const cancelBtn = document.getElementById('arr-setup-cancel');\n  const connectBtn = document.getElementById('smart-connect-btn');\n\n  // Phase elements\n  const phaseDetect = document.getElementById('smart-phase-detect');\n  const phaseCredentials = document.getElementById('smart-phase-credentials');\n  const phaseProgress = document.getElementById('smart-phase-progress');\n  const phaseResults = document.getElementById('smart-phase-results');\n\n  const detectResults = document.getElementById('smart-detect-results');\n  const credentialInputs = document.getElementById('smart-credential-inputs');\n  const progressSteps = document.getElementById('smart-progress-steps');\n  const resultsContent = document.getElementById('smart-results-content');\n  const plexLibraries = document.getElementById('smart-plex-libraries');\n  const retryBtn = document.getElementById('smart-retry-btn');\n\n  let detectedData = null; // Store detection results for smart-connect\n\n  const serviceIcons = { plex: '\uD83C\uDFAC', radarr: '\uD83C\uDFAC', sonarr: '\uD83D\uDCFA', prowlarr: '\uD83D\uDD0D', seerr: '\uD83D\uDCCB' };\n  const serviceLabels = { plex: 'Plex', radarr: 'Radarr (Movies)', sonarr: 'Sonarr (TV)', prowlarr: 'Prowlarr (Indexers)', seerr: 'Seerr' };\n\n  function showPhase(phase) {\n    phaseDetect.style.display = phase === 'detect' ? 'block' : 'none';\n    phaseCredentials.style.display = phase === 'credentials' ? 'block' : 'none';\n    phaseProgress.style.display = phase === 'progress' ? 'block' : 'none';\n    phaseResults.style.display = phase === 'results' ? 'block' : 'none';\n  }\n\n  function statusBadge(status) {\n    const colors = {\n      connected: { bg: 'var(--ok-fg)', icon: '&#10003;', text: 'Connected' },\n      needs_key: { bg: '#f39c12', icon: '&#128273;', text: 'Needs API Key' },\n      not_found: { bg: 'var(--muted)', icon: '&mdash;', text: 'Not Found' },\n      error: { bg: 'var(--bad-fg)', icon: '&#10007;', text: 'Error' }\n    };\n    const c = colors[status] || colors.not_found;\n    return `<span style=\"display: inline-flex; align-items: center; gap: 4px; padding: 2px 8px; border-radius: 4px; font-size: 0.75rem; background: color-mix(in srgb, ${c.bg} 20%, transparent); color: ${c.bg};\">${c.icon} ${c.text}</span>`;\n  }\n\n  // Phase 1: Smart Detection\n  async function smartDetect() {\n    showPhase('detect');\n    detectResults.style.display = 'none';\n\n    try {\n      const response = await fetch('/api/v1/arr/smart-detect');\n      detectedData = await response.json();\n\n      if (!detectedData.success) {\n        detectResults.innerHTML = `<div style=\"padding: 12px; color: var(--bad-fg);\">Detection failed: ${escapeHtml(detectedData.error)}</div>`;\n        detectResults.style.display = 'block';\n        return;\n      }\n\n      // Render detection results\n      let html = '<div style=\"display: flex; flex-direction: column; gap: 8px;\">';\n\n      for (const [svc, info] of Object.entries(detectedData.services)) {\n        const icon = serviceIcons[svc] || '\uD83D\uDCE6';\n        const label = serviceLabels[svc] || svc;\n        const source = info.source ? `<span style=\"font-size: 0.7rem; color: var(--muted); padding: 1px 6px; background: var(--card-bg); border-radius: 3px;\">${escapeHtml(info.source)}</span>` : '';\n        const version = info.version ? `<span style=\"font-size: 0.7rem; color: var(--muted);\">v${escapeHtml(info.version)}</span>` : '';\n        const keySaved = (info.hasApiKey || info.hasToken) && info.status === 'connected'\n          ? '<span style=\"font-size: 0.7rem; color: var(--ok-fg);\">Key saved</span>' : '';\n\n        html += `<div style=\"display: flex; align-items: center; gap: 10px; padding: 10px 12px; background: var(--card-base); border-radius: 8px; border: 1px solid var(--border);\">\n          <span style=\"font-size: 1.1rem;\">${icon}</span>\n          <div style=\"flex: 1;\">\n            <div style=\"font-weight: 500; font-size: 0.9rem;\">${label}</div>\n            <div style=\"display: flex; gap: 6px; align-items: center; flex-wrap: wrap;\">\n              ${source} ${version} ${keySaved}\n            </div>\n          </div>\n          ${statusBadge(info.status)}\n        </div>`;\n      }\n\n      html += '</div>';\n\n      // Summary\n      const s = detectedData.summary;\n      html += `<div style=\"margin-top: 12px; padding: 10px; background: color-mix(in srgb, var(--accent) 8%, transparent); border-radius: 8px; font-size: 0.85rem;\">\n        ${escapeHtml(String(s.fullyConnected))}/${escapeHtml(String(s.totalDetected + (5 - s.totalDetected)))} services detected &middot;\n        ${escapeHtml(String(s.fullyConnected))} connected${s.needsApiKey > 0 ? ` &middot; <strong>${escapeHtml(String(s.needsApiKey))} needs API key</strong>` : ''}\n      </div>`;\n\n      detectResults.innerHTML = html;\n      detectResults.style.display = 'block';\n\n      // Build credential inputs for services that need keys\n      buildCredentialInputs(detectedData);\n\n      // Auto-advance after a short delay\n      setTimeout(() => {\n        showPhase('credentials');\n      }, 800);\n\n    } catch (e) {\n      detectResults.innerHTML = `<div style=\"padding: 12px; color: var(--bad-fg);\">Error: ${escapeHtml(e.message)}</div>`;\n      detectResults.style.display = 'block';\n    }\n  }\n\n  // Build credential input fields\n  function buildCredentialInputs(data) {\n    let html = '';\n    const services = data.services;\n    const arrServices = ['radarr', 'sonarr', 'prowlarr'];\n\n    for (const svc of arrServices) {\n      const info = services[svc];\n      if (!info || info.status === 'not_found' && !info.url) continue;\n\n      const icon = serviceIcons[svc];\n      const label = serviceLabels[svc];\n      const isConnected = info.status === 'connected';\n      const borderColor = isConnected ? 'var(--ok-fg)' : 'var(--border)';\n\n      html += `<div style=\"margin-bottom: 10px; padding: 12px; background: var(--card-base); border-radius: 8px; border: 1px solid ${borderColor};\">\n        <div style=\"display: flex; align-items: center; gap: 8px; margin-bottom: 8px;\">\n          <span style=\"font-size: 1.1rem;\">${icon}</span>\n          <span style=\"font-weight: 500;\">${label}</span>\n          <span id=\"smart-${svc}-status\" style=\"margin-left: auto; font-size: 0.75rem;\">\n            ${isConnected ? '<span style=\"color: var(--ok-fg);\">&#10003; Connected</span>' : ''}\n          </span>\n        </div>\n        <div style=\"display: grid; grid-template-columns: 2fr 1fr; gap: 8px;\">\n          <div>\n            <label style=\"font-size: 0.75rem; color: var(--muted);\">URL:</label>\n            <input type=\"text\" id=\"smart-${svc}-url\" value=\"${escapeHtml(info.url || '')}\" placeholder=\"https://seedbox.com/${svc}/\"\n                   style=\"width: 100%; font-size: 0.85rem; padding: 6px 8px; background: var(--card-bg); color: var(--fg); border: 1px solid var(--border); border-radius: 4px;\" />\n          </div>\n          <div>\n            <label style=\"font-size: 0.75rem; color: var(--muted);\">API Key:</label>\n            <input type=\"password\" id=\"smart-${svc}-key\" placeholder=\"${isConnected ? '(saved)' : 'Paste API key'}\"\n                   style=\"width: 100%; font-size: 0.85rem; padding: 6px 8px; background: var(--card-bg); color: var(--fg); border: 1px solid var(--border); border-radius: 4px;\" />\n          </div>\n        </div>\n        <button onclick=\"smartTestConnection('${svc}')\" style=\"margin-top: 8px; padding: 4px 12px; font-size: 0.75rem; cursor: pointer;\">Test</button>\n      </div>`;\n    }\n\n    // Plex status (non-editable, just shows status)\n    const plex = services.plex;\n    if (plex) {\n      const plexConnected = plex.status === 'connected';\n      html += `<div style=\"padding: 10px 12px; background: var(--card-base); border-radius: 8px; border: 1px solid ${plexConnected ? 'var(--ok-fg)' : 'var(--border)'}; margin-bottom: 10px;\">\n        <div style=\"display: flex; align-items: center; gap: 8px;\">\n          <span style=\"font-size: 1.1rem;\">\uD83C\uDFAC</span>\n          <span style=\"font-weight: 500;\">Plex</span>\n          ${statusBadge(plex.status)}\n          <span style=\"margin-left: auto; font-size: 0.75rem; color: var(--muted);\">${escapeHtml(plex.source || '')}</span>\n        </div>\n      </div>`;\n    }\n\n    // Seerr status\n    const seerr = services.seerr;\n    if (seerr) {\n      const seerrOk = seerr.status === 'connected';\n      let configuredHtml = '';\n      if (seerr.configuredServices) {\n        const cs = seerr.configuredServices;\n        configuredHtml = `<div style=\"font-size: 0.75rem; color: var(--muted); margin-top: 4px;\">\n          Configured: ${cs.radarr ? '&#10003; Radarr' : '&#10007; Radarr'} &middot;\n          ${cs.sonarr ? '&#10003; Sonarr' : '&#10007; Sonarr'} &middot;\n          ${cs.plex ? '&#10003; Plex' : '&#10007; Plex'}\n        </div>`;\n      }\n      html += `<div style=\"padding: 10px 12px; background: var(--card-base); border-radius: 8px; border: 1px solid ${seerrOk ? 'var(--ok-fg)' : 'var(--border)'};\">\n        <div style=\"display: flex; align-items: center; gap: 8px;\">\n          <span style=\"font-size: 1.1rem;\">\uD83D\uDCCB</span>\n          <span style=\"font-weight: 500;\">Seerr</span>\n          ${statusBadge(seerr.status)}\n        </div>\n        ${configuredHtml}\n      </div>`;\n    }\n\n    credentialInputs.innerHTML = html;\n  }\n\n  // Test connection (global for onclick)\n  window.smartTestConnection = async function(service) {\n    const urlInput = document.getElementById(`smart-${service}-url`);\n    const keyInput = document.getElementById(`smart-${service}-key`);\n    const statusSpan = document.getElementById(`smart-${service}-status`);\n\n    const url = urlInput?.value.trim();\n    const apiKey = keyInput?.value.trim();\n\n    if (!url || !apiKey) {\n      statusSpan.innerHTML = '<span style=\"color: var(--bad-fg);\">Enter URL and API key</span>';\n      return;\n    }\n\n    statusSpan.innerHTML = '<span class=\"brand-spinner\"></span>';\n\n    try {\n      const response = await secureFetch('/api/v1/arr/test-connection', {\n        method: 'POST',\n        headers: { 'Content-Type': 'application/json' },\n        body: JSON.stringify({ service, url, apiKey })\n      });\n      const data = await response.json();\n      if (data.success) {\n        statusSpan.innerHTML = `<span style=\"color: var(--ok-fg);\">&#10003; ${escapeHtml(data.appName || 'Connected')} v${escapeHtml(data.version || '')}</span>`;\n      } else {\n        statusSpan.innerHTML = `<span style=\"color: var(--bad-fg);\">&#10007; ${escapeHtml(data.error)}</span>`;\n      }\n    } catch (e) {\n      statusSpan.innerHTML = `<span style=\"color: var(--bad-fg);\">&#10007; ${escapeHtml(e.message)}</span>`;\n    }\n  };\n\n  // Phase 3: Smart Connect\n  async function smartConnect() {\n    showPhase('progress');\n    progressSteps.innerHTML = '<div style=\"text-align: center; padding: 20px;\"><span class=\"brand-spinner\"></span><div style=\"color: var(--muted); margin-top: 8px;\">Connecting services...</div></div>';\n\n    // Gather input\n    const services = {};\n    for (const svc of ['radarr', 'sonarr', 'prowlarr']) {\n      const url = document.getElementById(`smart-${svc}-url`)?.value.trim();\n      const apiKey = document.getElementById(`smart-${svc}-key`)?.value.trim();\n      if (apiKey && url) {\n        services[svc] = { apiKey, url };\n      } else if (apiKey) {\n        // Key provided without URL - let backend resolve\n        services[svc] = { apiKey };\n      }\n      // If no key entered but service was already connected, backend uses stored credentials\n    }\n\n    const payload = {\n      services: Object.keys(services).length > 0 ? services : undefined,\n      configurePlex: document.getElementById('smart-opt-plex')?.checked,\n      configureProwlarr: document.getElementById('smart-opt-prowlarr')?.checked,\n      configureSeerr: document.getElementById('smart-opt-seerr')?.checked,\n      saveCredentials: document.getElementById('smart-opt-save')?.checked\n    };\n\n    try {\n      const response = await secureFetch('/api/v1/arr/smart-connect', {\n        method: 'POST',\n        headers: { 'Content-Type': 'application/json' },\n        body: JSON.stringify(payload)\n      });\n\n      const data = await response.json();\n\n      // Render progress steps\n      let stepsHtml = '';\n      for (const step of (data.steps || [])) {\n        const icon = step.status === 'success' ? '<span style=\"color: var(--ok-fg);\">&#10003;</span>'\n                   : '<span style=\"color: var(--bad-fg);\">&#10007;</span>';\n        const detailColor = step.status === 'success' ? 'var(--muted)' : 'var(--bad-fg)';\n        stepsHtml += `<div style=\"display: flex; align-items: center; gap: 8px; padding: 6px 10px; background: var(--card-base); border-radius: 6px; font-size: 0.85rem;\">\n          ${icon}\n          <span>${escapeHtml(step.step)}</span>\n          <span style=\"margin-left: auto; font-size: 0.75rem; color: ${detailColor};\">${escapeHtml(step.details || '')}</span>\n        </div>`;\n      }\n      progressSteps.innerHTML = stepsHtml;\n\n      // Show results after brief delay\n      setTimeout(() => showResults(data), 500);\n\n    } catch (e) {\n      progressSteps.innerHTML = `<div style=\"padding: 12px; color: var(--bad-fg);\">Connection error: ${escapeHtml(e.message)}</div>`;\n    }\n  }\n\n  // Phase 4: Results\n  function showResults(data) {\n    showPhase('results');\n\n    const s = data.summary || {};\n    const allGood = s.failed === 0 && s.succeeded > 0;\n    const headerColor = allGood ? 'var(--ok-fg)' : '#f39c12';\n    const headerIcon = allGood ? '&#10003;' : '&#9888;';\n    const headerText = allGood ? 'All Connected!' : `${escapeHtml(String(s.succeeded))}/${escapeHtml(String(s.totalSteps))} Steps Succeeded`;\n\n    let html = `<div style=\"text-align: center; padding: 16px; background: color-mix(in srgb, ${headerColor} 12%, transparent); border-radius: 10px; border: 1px solid ${headerColor}; margin-bottom: 12px;\">\n      <div style=\"font-size: 1.5rem; color: ${headerColor};\">${headerIcon}</div>\n      <div style=\"font-size: 1.1rem; font-weight: 600; color: ${headerColor};\">${headerText}</div>\n      <div style=\"font-size: 0.85rem; color: var(--muted); margin-top: 4px;\">${escapeHtml(String(s.succeeded))} succeeded, ${escapeHtml(String(s.failed))} failed</div>\n    </div>`;\n\n    // Steps detail\n    html += '<div style=\"display: flex; flex-direction: column; gap: 4px;\">';\n    for (const step of (data.steps || [])) {\n      const icon = step.status === 'success' ? '<span style=\"color: var(--ok-fg);\">&#10003;</span>'\n                 : '<span style=\"color: var(--bad-fg);\">&#10007;</span>';\n      html += `<div style=\"display: flex; align-items: center; gap: 8px; padding: 4px 8px; font-size: 0.8rem;\">\n        ${icon} ${escapeHtml(step.step)} <span style=\"margin-left: auto; color: var(--muted); font-size: 0.75rem;\">${escapeHtml(step.details || '')}</span>\n      </div>`;\n    }\n    html += '</div>';\n\n    resultsContent.innerHTML = html;\n\n    // Show retry button if any failures\n    retryBtn.style.display = s.failed > 0 ? 'block' : 'none';\n\n    // Fetch Plex libraries if Plex was connected\n    if (data.steps?.some(st => st.step.includes('Plex') && st.status === 'success')) {\n      fetchPlexLibraries();\n    }\n  }\n\n  async function fetchPlexLibraries() {\n    try {\n      const res = await fetch('/api/v1/plex/libraries');\n      const data = await res.json();\n      if (data.success && data.libraries?.length > 0) {\n        let html = `<div style=\"padding: 12px; background: var(--card-base); border-radius: 8px; border: 1px solid var(--border);\">\n          <h4 style=\"margin: 0 0 8px; font-size: 0.85rem; color: var(--accent);\">\uD83C\uDFAC ${escapeHtml(data.serverName)} Libraries</h4>\n          <div style=\"display: flex; flex-wrap: wrap; gap: 8px;\">`;\n        for (const lib of data.libraries) {\n          const typeIcon = lib.type === 'movie' ? '\uD83C\uDFAC' : lib.type === 'show' ? '\uD83D\uDCFA' : '\uD83C\uDFB5';\n          html += `<div style=\"padding: 8px 12px; background: var(--card-bg); border-radius: 6px; font-size: 0.85rem;\">\n            ${typeIcon} <strong>${escapeHtml(lib.title)}</strong>\n            <span style=\"color: var(--muted); font-size: 0.75rem;\">${escapeHtml(String(lib.count))} items</span>\n          </div>`;\n        }\n        html += '</div></div>';\n        plexLibraries.innerHTML = html;\n        plexLibraries.style.display = 'block';\n      }\n    } catch (e) {\n      // Ignore Plex library fetch errors\n    }\n  }\n\n  // Event listeners\n  openBtn?.addEventListener('click', () => {\n    modal.classList.add('show');\n    plexLibraries.style.display = 'none';\n    smartDetect();\n  });\n\n  wireModal(modal, cancelBtn);\n  connectBtn?.addEventListener('click', smartConnect);\n  retryBtn?.addEventListener('click', smartConnect);\n})();\n;\n// ========== NOTIFICATION SETTINGS ==========\n(function() {\n  const errorHandler = new ErrorHandler();\n  // Inject modal HTML\n  injectModal('notifications-modal', `<div id=\"notifications-modal\" class=\"weather-modal\">\n    <div class=\"weather-modal-content\" style=\"min-width: 550px; max-width: 650px;\">\n      <h3>\uD83D\uDD14 Notification Settings</h3>\n\n      <!-- Master Toggle -->\n      <div class=\"accent-info-box\">\n        <label style=\"display: flex; align-items: center; gap: 10px; cursor: pointer;\">\n          <input type=\"checkbox\" id=\"notifications-enabled\" />\n          <div>\n            <span style=\"font-weight: 600; color: var(--accent);\">Enable Notifications</span>\n            <div class=\"text-tiny-muted\">Receive alerts when containers go up/down</div>\n          </div>\n        </label>\n      </div>\n\n      <!-- Providers Section -->\n      <h4 class=\"section-heading\">Notification Providers</h4>\n\n      <!-- Discord -->\n      <div class=\"notification-provider provider-card\">\n        <div class=\"provider-header\">\n          <label class=\"checkbox-label\">\n            <input type=\"checkbox\" id=\"discord-enabled\" />\n            <span class=\"fw-500\">Discord</span>\n          </label>\n          <button id=\"discord-test\" class=\"test-btn btn-xs\">Test</button>\n        </div>\n        <div id=\"discord-config\" style=\"display: none;\">\n          <label class=\"field-label-sm\">Webhook URL:</label>\n          <input type=\"text\" id=\"discord-webhook\" placeholder=\"https://discord.com/api/v1/webhooks/...\" style=\"width: 100%;\" />\n        </div>\n      </div>\n\n      <!-- Telegram -->\n      <div class=\"notification-provider provider-card\">\n        <div class=\"provider-header\">\n          <label class=\"checkbox-label\">\n            <input type=\"checkbox\" id=\"telegram-enabled\" />\n            <span class=\"fw-500\">Telegram</span>\n          </label>\n          <button id=\"telegram-test\" class=\"test-btn btn-xs\">Test</button>\n        </div>\n        <div id=\"telegram-config\" style=\"display: none;\">\n          <div class=\"grid-2col\">\n            <div>\n              <label class=\"field-label-sm\">Bot Token:</label>\n              <input type=\"text\" id=\"telegram-bot-token\" placeholder=\"123456:ABC...\" />\n            </div>\n            <div>\n              <label class=\"field-label-sm\">Chat ID:</label>\n              <input type=\"text\" id=\"telegram-chat-id\" placeholder=\"-1001234567890\" />\n            </div>\n          </div>\n        </div>\n      </div>\n\n      <!-- ntfy.sh -->\n      <div class=\"notification-provider provider-card\">\n        <div class=\"provider-header\">\n          <label class=\"checkbox-label\">\n            <input type=\"checkbox\" id=\"ntfy-enabled\" />\n            <span class=\"fw-500\">ntfy.sh</span>\n          </label>\n          <button id=\"ntfy-test\" class=\"test-btn btn-xs\">Test</button>\n        </div>\n        <div id=\"ntfy-config\" style=\"display: none;\">\n          <div style=\"display: grid; grid-template-columns: 2fr 1fr; gap: 8px;\">\n            <div>\n              <label class=\"field-label-sm\">Server URL:</label>\n              <input type=\"text\" id=\"ntfy-server\" placeholder=\"https://ntfy.sh\" value=\"https://ntfy.sh\" />\n            </div>\n            <div>\n              <label class=\"field-label-sm\">Topic:</label>\n              <input type=\"text\" id=\"ntfy-topic\" placeholder=\"dashcaddy-alerts\" />\n            </div>\n          </div>\n        </div>\n      </div>\n\n      <!-- Email -->\n      <div class=\"notification-provider provider-card\">\n        <div class=\"provider-header\">\n          <label class=\"checkbox-label\">\n            <input type=\"checkbox\" id=\"email-enabled\" />\n            <span class=\"fw-500\">Email (SMTP)</span>\n          </label>\n          <button id=\"email-test\" class=\"test-btn btn-xs\">Test</button>\n        </div>\n        <div id=\"email-config\" style=\"display: none;\">\n          <div style=\"display: grid; grid-template-columns: 2fr 1fr; gap: 8px; margin-bottom: 8px;\">\n            <div>\n              <label class=\"field-label-sm\">SMTP Host:</label>\n              <input type=\"text\" id=\"email-host\" placeholder=\"smtp.gmail.com\" />\n            </div>\n            <div>\n              <label class=\"field-label-sm\">Port:</label>\n              <input type=\"number\" id=\"email-port\" value=\"587\" placeholder=\"587\" />\n            </div>\n          </div>\n          <div style=\"display: grid; grid-template-columns: 1fr 1fr; gap: 8px; margin-bottom: 8px;\">\n            <div>\n              <label class=\"field-label-sm\">Username:</label>\n              <input type=\"text\" id=\"email-user\" placeholder=\"user@gmail.com\" />\n            </div>\n            <div>\n              <label class=\"field-label-sm\">Password:</label>\n              <input type=\"password\" id=\"email-pass\" placeholder=\"app password\" />\n            </div>\n          </div>\n          <div style=\"display: grid; grid-template-columns: 1fr 1fr; gap: 8px;\">\n            <div>\n              <label class=\"field-label-sm\">From:</label>\n              <input type=\"text\" id=\"email-from\" placeholder=\"DashCaddy &lt;noreply@example.com&gt;\" />\n            </div>\n            <div>\n              <label class=\"field-label-sm\">To:</label>\n              <input type=\"text\" id=\"email-to\" placeholder=\"admin@example.com\" />\n            </div>\n          </div>\n          <label style=\"display: flex; align-items: center; gap: 6px; margin-top: 8px; font-size: 0.8rem;\">\n            <input type=\"checkbox\" id=\"email-secure\" /> Use TLS (port 465)\n          </label>\n        </div>\n      </div>\n\n      <!-- Health Check Settings -->\n      <h4 class=\"section-heading\">Health Monitoring</h4>\n      <div style=\"padding: 12px; background: var(--card-base); border-radius: 8px; border: 1px solid var(--border);\">\n        <label style=\"display: flex; align-items: center; gap: 10px; cursor: pointer; margin-bottom: 10px;\">\n          <input type=\"checkbox\" id=\"health-check-enabled\" />\n          <div>\n            <span class=\"fw-500\">Enable Health Monitoring</span>\n            <div class=\"text-tiny-muted\">Periodically check container status</div>\n          </div>\n        </label>\n        <div id=\"health-check-config\" style=\"display: flex; align-items: center; gap: 10px;\">\n          <label class=\"field-label-sm\">Check interval:</label>\n          <select id=\"health-check-interval\" style=\"width: auto;\">\n            <option value=\"1\">1 minute</option>\n            <option value=\"5\" selected>5 minutes</option>\n            <option value=\"15\">15 minutes</option>\n            <option value=\"30\">30 minutes</option>\n            <option value=\"60\">1 hour</option>\n          </select>\n          <button id=\"health-check-now\" style=\"padding: 4px 10px; font-size: 0.75rem; margin-left: auto;\">Check Now</button>\n        </div>\n        <div id=\"health-check-status\" style=\"font-size: 0.75rem; color: var(--muted); margin-top: 8px;\">\n          Last check: Never\n        </div>\n      </div>\n\n      <!-- Event Types -->\n      <h4 class=\"section-heading\">Events to Notify</h4>\n      <div style=\"display: grid; grid-template-columns: 1fr 1fr; gap: 6px; padding: 12px; background: var(--card-base); border-radius: 8px; border: 1px solid var(--border);\">\n        <label class=\"checkbox-label-sm\">\n          <input type=\"checkbox\" id=\"event-container-down\" checked /> Container Down\n        </label>\n        <label class=\"checkbox-label-sm\">\n          <input type=\"checkbox\" id=\"event-container-up\" checked /> Container Recovered\n        </label>\n        <label class=\"checkbox-label-sm\">\n          <input type=\"checkbox\" id=\"event-deploy-success\" checked /> Deployment Success\n        </label>\n        <label class=\"checkbox-label-sm\">\n          <input type=\"checkbox\" id=\"event-deploy-failed\" checked /> Deployment Failed\n        </label>\n        <label class=\"checkbox-label-sm\">\n          <input type=\"checkbox\" id=\"event-ssl-cert-expiry\" checked /> SSL Expiry\n        </label>\n        <label class=\"checkbox-label-sm\">\n          <input type=\"checkbox\" id=\"event-dns-propagation\" checked /> DNS Propagation\n        </label>\n        <label class=\"checkbox-label-sm\">\n          <input type=\"checkbox\" id=\"event-drift-detected\" checked /> Config Drift\n        </label>\n        <label class=\"checkbox-label-sm\">\n          <input type=\"checkbox\" id=\"event-dependency-restart\" checked /> Dependency Restarts\n        </label>\n        <label class=\"checkbox-label-sm\">\n          <input type=\"checkbox\" id=\"event-recipe-removed\" checked /> Recipe Removed\n        </label>\n        <label class=\"checkbox-label-sm\">\n          <input type=\"checkbox\" id=\"event-workflow\" checked /> Workflow Actions\n        </label>\n        <label class=\"checkbox-label-sm\">\n          <input type=\"checkbox\" id=\"event-backup-complete\" checked /> Backup Complete\n        </label>\n        <label class=\"checkbox-label-sm\">\n          <input type=\"checkbox\" id=\"event-backup-failed\" checked /> Backup Failed\n        </label>\n        <label class=\"checkbox-label-sm\">\n          <input type=\"checkbox\" id=\"event-update-available\" checked /> Updates\n        </label>\n        <label class=\"checkbox-label-sm\" style=\"grid-column: 1 / -1;\">\n          <input type=\"checkbox\" id=\"event-resource-alert\" checked /> Resource Alerts\n        </label>\n      </div>\n\n      <!-- History -->\n      <h4 class=\"section-heading\">Notification History</h4>\n      <div id=\"notification-history\" style=\"max-height: 150px; overflow-y: auto; padding: 8px; background: var(--card-base); border-radius: 8px; border: 1px solid var(--border); font-size: 0.8rem;\">\n        <div style=\"color: var(--muted); text-align: center; padding: 20px;\">No notifications yet</div>\n      </div>\n      <div id=\"last-notification-sent\" style=\"font-size: 0.75rem; color: var(--muted); text-align: center; margin-top: 6px;\"></div>\n\n      <!-- Buttons -->\n      <div class=\"weather-modal-buttons modal-footer-bar\">\n        <button id=\"notifications-send-test\" class=\"btn-secondary\" style=\"margin-right: auto;\">Send Test</button>\n        <button id=\"notifications-cancel\">Cancel</button>\n        <button id=\"notifications-save\" class=\"btn-accent\">Save Settings</button>\n      </div>\n    </div>\n  </div>`);\n\n  const modal = document.getElementById('notifications-modal');\n  const openBtn = document.getElementById('manage-notifications');\n  const saveBtn = document.getElementById('notifications-save');\n  const cancelBtn = document.getElementById('notifications-cancel');\n\n  // Provider toggle handlers\n  ['discord', 'telegram', 'ntfy', 'email'].forEach(provider => {\n    const checkbox = document.getElementById(`${provider}-enabled`);\n    const config = document.getElementById(`${provider}-config`);\n\n    checkbox?.addEventListener('change', () => {\n      config.style.display = checkbox.checked ? 'block' : 'none';\n    });\n  });\n\n  // Health check toggle\n  const healthCheckEnabled = document.getElementById('health-check-enabled');\n  const healthCheckConfig = document.getElementById('health-check-config');\n  healthCheckEnabled?.addEventListener('change', () => {\n    healthCheckConfig.style.opacity = healthCheckEnabled.checked ? '1' : '0.5';\n  });\n\n  // Load notification config from API\n  async function loadNotificationConfig() {\n    try {\n      const response = await fetch('/api/v1/notifications/config');\n      const data = await response.json();\n\n      if (data.success) {\n        const config = data.config;\n\n        // Master toggle\n        document.getElementById('notifications-enabled').checked = config.enabled;\n\n        // Providers\n        document.getElementById('discord-enabled').checked = config.providers?.discord?.enabled || false;\n        document.getElementById('telegram-enabled').checked = config.providers?.telegram?.enabled || false;\n        document.getElementById('ntfy-enabled').checked = config.providers?.ntfy?.enabled || false;\n        document.getElementById('email-enabled').checked = config.providers?.email?.enabled || false;\n\n        // Show/hide config sections\n        document.getElementById('discord-config').style.display = config.providers?.discord?.enabled ? 'block' : 'none';\n        document.getElementById('telegram-config').style.display = config.providers?.telegram?.enabled ? 'block' : 'none';\n        document.getElementById('ntfy-config').style.display = config.providers?.ntfy?.enabled ? 'block' : 'none';\n        document.getElementById('email-config').style.display = config.providers?.email?.enabled ? 'block' : 'none';\n\n        // ntfy server URL\n        if (config.providers?.ntfy?.serverUrl) {\n          document.getElementById('ntfy-server').value = config.providers.ntfy.serverUrl;\n        }\n\n        // email fields \u2014 DC-092: prefill the FULL form so a save doesn't\n        // silently wipe fields the GET response previously omitted. Password\n        // is never returned; when one is stored the field shows a keep-hint\n        // and an empty submit preserves the stored credential server-side.\n        if (config.providers?.email?.host) document.getElementById('email-host').value = config.providers.email.host;\n        if (config.providers?.email?.from) document.getElementById('email-from').value = config.providers.email.from;\n        if (config.providers?.email?.to) document.getElementById('email-to').value = config.providers.email.to;\n        if (config.providers?.email?.port) document.getElementById('email-port').value = config.providers.email.port;\n        if (config.providers?.email?.secure !== undefined) document.getElementById('email-secure').checked = config.providers.email.secure === true;\n        if (config.providers?.email?.username) document.getElementById('email-user').value = config.providers.email.username;\n        const emailPassEl = document.getElementById('email-pass');\n        if (config.providers?.email?.hasPassword) {\n          emailPassEl.value = '';\n          emailPassEl.placeholder = 'saved \u2014 leave blank to keep';\n        } else {\n          emailPassEl.placeholder = 'app password';\n        }\n\n        // Health check\n        document.getElementById('health-check-enabled').checked = config.healthCheck?.enabled || false;\n        if (config.healthCheck?.intervalMinutes) {\n          document.getElementById('health-check-interval').value = config.healthCheck.intervalMinutes;\n        }\n        if (config.healthCheck?.lastCheck) {\n          document.getElementById('health-check-status').textContent =\n            `Last check: ${new Date(config.healthCheck.lastCheck).toLocaleString()}`;\n        }\n\n        // Events \u2014 canonical kebab-case keys, matching the backend store\n        // (DC-092: previously read camelCase keys that never existed, so\n        // every toggle re-rendered as 'checked' regardless of stored state).\n        document.getElementById('event-container-down').checked = config.events?.['container-down'] !== false;\n        document.getElementById('event-container-up').checked = config.events?.['container-up'] === true;\n        document.getElementById('event-deploy-success').checked = config.events?.['deploy-success'] !== false;\n        document.getElementById('event-deploy-failed').checked = config.events?.['deploy-failed'] !== false;\n        document.getElementById('event-ssl-cert-expiry').checked = config.events?.['ssl-cert-expiry'] !== false;\n        document.getElementById('event-dns-propagation').checked = config.events?.['dns-propagation'] !== false;\n        document.getElementById('event-drift-detected').checked = config.events?.['drift-detected'] !== false;\n        document.getElementById('event-dependency-restart').checked = config.events?.['dependency-restart'] !== false;\n        document.getElementById('event-recipe-removed').checked = config.events?.['recipe-removed'] !== false;\n        document.getElementById('event-workflow').checked = config.events?.['workflow'] !== false;\n        document.getElementById('event-backup-complete').checked = config.events?.['backup-complete'] !== false;\n        document.getElementById('event-backup-failed').checked = config.events?.['backup-failed'] !== false;\n        document.getElementById('event-update-available').checked = config.events?.['update-available'] !== false;\n        document.getElementById('event-resource-alert').checked = config.events?.['alert'] !== false;\n      }\n    } catch (error) {\n      errorHandler.logError('[Notifications] Load Config', error, { function: 'loadConfig' });\n    }\n  }\n\n  // Load notification history\n  async function loadNotificationHistory() {\n    try {\n      const response = await fetch('/api/v1/notifications/history?limit=10');\n      const data = await response.json();\n\n      const container = document.getElementById('notification-history');\n      if (data.success && data.history?.length > 0) {\n        container.innerHTML = data.history.map(item => {\n          const date = new Date(item.timestamp).toLocaleString();\n          const typeColors = {\n            success: 'var(--ok-fg)',\n            error: 'var(--bad-fg)',\n            warning: '#f39c12',\n            info: 'var(--accent)'\n          };\n          return `\n            <div style=\"padding: 6px 8px; border-bottom: 1px solid var(--border); display: flex; gap: 8px; align-items: flex-start;\">\n              <span style=\"color: ${typeColors[item.type] || 'var(--muted)'}\">${item.type === 'success' ? '\u2713' : item.type === 'error' ? '\u2717' : '\u2139'}</span>\n              <div style=\"flex: 1; min-width: 0;\">\n                <div style=\"font-weight: 500; white-space: nowrap; overflow: hidden; text-overflow: ellipsis;\">${escapeHtml(item.title)}</div>\n                <div style=\"font-size: 0.7rem; color: var(--muted);\">${date}</div>\n              </div>\n            </div>\n          `;\n        }).join('');\n      } else {\n        container.innerHTML = '<div style=\"color: var(--muted); text-align: center; padding: 20px;\">No notifications yet</div>';\n      }\n    } catch (error) {\n      errorHandler.logError('[Notifications] Load History', error, { function: 'loadHistory' });\n    }\n  }\n\n  // Save notification config\n  async function saveNotificationConfig() {\n    try {\n      const config = {\n        enabled: document.getElementById('notifications-enabled').checked,\n        providers: {\n          discord: {\n            enabled: document.getElementById('discord-enabled').checked,\n            webhookUrl: document.getElementById('discord-webhook').value.trim()\n          },\n          telegram: {\n            enabled: document.getElementById('telegram-enabled').checked,\n            botToken: document.getElementById('telegram-bot-token').value.trim(),\n            chatId: document.getElementById('telegram-chat-id').value.trim()\n          },\n          ntfy: {\n            enabled: document.getElementById('ntfy-enabled').checked,\n            serverUrl: document.getElementById('ntfy-server').value.trim() || 'https://ntfy.sh',\n            topic: document.getElementById('ntfy-topic').value.trim()\n          },\n          email: {\n            enabled: document.getElementById('email-enabled').checked,\n            host: document.getElementById('email-host').value.trim(),\n            port: parseInt(document.getElementById('email-port').value) || 587,\n            secure: document.getElementById('email-secure').checked,\n            username: document.getElementById('email-user').value.trim(),\n            password: document.getElementById('email-pass').value.trim(),\n            from: document.getElementById('email-from').value.trim(),\n            to: document.getElementById('email-to').value.trim()\n          }\n        },\n        events: {\n          'container-down': document.getElementById('event-container-down').checked,\n          'container-up': document.getElementById('event-container-up').checked,\n          'deploy-success': document.getElementById('event-deploy-success').checked,\n          'deploy-failed': document.getElementById('event-deploy-failed').checked,\n          'ssl-cert-expiry': document.getElementById('event-ssl-cert-expiry').checked,\n          'dns-propagation': document.getElementById('event-dns-propagation').checked,\n          'drift-detected': document.getElementById('event-drift-detected').checked,\n          'dependency-restart': document.getElementById('event-dependency-restart').checked,\n          'recipe-removed': document.getElementById('event-recipe-removed').checked,\n          'workflow': document.getElementById('event-workflow').checked,\n          'backup-complete': document.getElementById('event-backup-complete').checked,\n          'backup-failed': document.getElementById('event-backup-failed').checked,\n          'update-available': document.getElementById('event-update-available').checked,\n          'alert': document.getElementById('event-resource-alert').checked\n        },\n        healthCheck: {\n          enabled: document.getElementById('health-check-enabled').checked,\n          intervalMinutes: parseInt(document.getElementById('health-check-interval').value) || 5\n        }\n      };\n\n      const response = await secureFetch('/api/v1/notifications/config', {\n        method: 'POST',\n        headers: { 'Content-Type': 'application/json' },\n        body: JSON.stringify(config)\n      });\n\n      const data = await response.json();\n      if (data.success) {\n        showNotification('Notification settings saved', 'success', 3000);\n        modal.classList.remove('show');\n      } else {\n        showNotification(`Failed to save: ${data.error}`, 'error', 3000);\n      }\n    } catch (error) {\n      showNotification(`Error: ${error.message}`, 'error', 3000);\n    }\n  }\n\n  // Test notification handlers\n  async function testProvider(provider) {\n    try {\n      const response = await secureFetch('/api/v1/notifications/test', {\n        method: 'POST',\n        headers: { 'Content-Type': 'application/json' },\n        body: JSON.stringify({ provider })\n      });\n\n      const data = await response.json();\n      if (data.success) {\n        showNotification(`Test ${provider} notification sent!`, 'success', 3000);\n      } else {\n        showNotification(`Test failed: ${data.error}`, 'error', 3000);\n      }\n    } catch (error) {\n      showNotification(`Error: ${error.message}`, 'error', 3000);\n    }\n  }\n\n  document.getElementById('discord-test')?.addEventListener('click', () => testProvider('discord'));\n  document.getElementById('telegram-test')?.addEventListener('click', () => testProvider('telegram'));\n  document.getElementById('ntfy-test')?.addEventListener('click', () => testProvider('ntfy'));\n  document.getElementById('email-test')?.addEventListener('click', () => testProvider('email'));\n\n  // Health check now button\n  document.getElementById('health-check-now')?.addEventListener('click', async () => {\n    try {\n      const response = await secureFetch('/api/v1/notifications/health-check', { method: 'POST' });\n      const data = await response.json();\n\n      if (data.success) {\n        document.getElementById('health-check-status').textContent =\n          `Last check: ${new Date(data.lastCheck).toLocaleString()} (${data.containersMonitored} containers)`;\n        showNotification('Health check completed', 'success', 2000);\n      }\n    } catch (error) {\n      showNotification(`Error: ${error.message}`, 'error', 3000);\n    }\n  });\n\n  // Modal handlers\n  openBtn?.addEventListener('click', () => {\n    modal.classList.add('show');\n    loadNotificationConfig();\n    loadNotificationHistory();\n  });\n\n  saveBtn?.addEventListener('click', saveNotificationConfig);\n\n  // Send Test button - sends test notification to all enabled providers\n  document.getElementById('notifications-send-test')?.addEventListener('click', async () => {\n    const btn = document.getElementById('notifications-send-test');\n    const originalText = btn.textContent;\n    btn.textContent = 'Sending...';\n    btn.disabled = true;\n\n    try {\n      const response = await secureFetch('/api/v1/notifications/send', {\n        method: 'POST',\n        headers: { 'Content-Type': 'application/json' },\n        body: JSON.stringify({ \n          event: 'test',\n          data: { message: 'This is a test notification from DashCaddy.' },\n          type: 'info'\n        })\n      });\n\n      const data = await response.json();\n      if (data.success) {\n        showNotification('Test notification sent!', 'success', 3000);\n        // Update last sent timestamp\n        loadNotificationStatus();\n      } else {\n        showNotification(`Test failed: ${data.results?.map(r => `${r.provider}: ${r.error || 'ok'}`).join(', ')}`, 'error', 5000);\n      }\n    } catch (error) {\n      showNotification(`Error: ${error.message}`, 'error', 3000);\n    } finally {\n      btn.textContent = originalText;\n      btn.disabled = false;\n    }\n  });\n\n  // Load notification status (last sent timestamp)\n  async function loadNotificationStatus() {\n    try {\n      const response = await fetch('/api/v1/notifications/status');\n      const data = await response.json();\n      if (data.success && data.lastSent) {\n        const lastSentEl = document.getElementById('last-notification-sent');\n        if (lastSentEl) {\n          lastSentEl.textContent = `Last sent: ${new Date(data.lastSent).toLocaleString()}`;\n        }\n      }\n    } catch (error) {\n      // Silently fail - status is not critical\n    }\n  }\n\n  wireModal(modal, cancelBtn);\n})();\n;\n// ========== PANEL TAB SWITCHING (shared utility) ==========\n(function() {\n  document.addEventListener('click', (e) => {\n    const tab = e.target.closest('.panel-tab');\n    if (!tab) return;\n    const panelId = tab.dataset.panel;\n    if (!panelId) return;\n    const tabBar = tab.closest('.panel-tabs');\n    const modalContent = tabBar.closest('.weather-modal-content');\n    tabBar.querySelectorAll('.panel-tab').forEach(t => t.classList.remove('active'));\n    tab.classList.add('active');\n    modalContent.querySelectorAll('.panel-section').forEach(s => s.classList.remove('active'));\n    const target = modalContent.querySelector('#' + panelId);\n    if (target) target.classList.add('active');\n  });\n})();\n;\n// ========== UNIFIED BACKUP/RESTORE v2.0 ==========\n// Single file captures everything: server config + browser state + themes + encryption key\n(function() {\n  // All DashCaddy localStorage keys to include in backup\n  var BROWSER_STATE_KEYS = [\n    'dashcaddy_site_config', 'dashcaddy_onboarding', 'dashcaddy-encryption-key',\n    'dashcaddy-setup', 'dashcaddy-config',\n    'theme', 'user-themes', 'custom-theme',\n    'custom-apps', 'custom-services', 'toolbar-sections',\n    'weather-location', 'weather-zip', 'weather-geo', 'weather-unit',\n    'clock-style', 'clock-chimes', 'clock-chime-volume'\n  ];\n\n  // Collect all DashCaddy browser state from localStorage\n  function collectBrowserState() {\n    var state = {};\n    // Grab all whitelisted keys\n    for (var i = 0; i < BROWSER_STATE_KEYS.length; i++) {\n      var key = BROWSER_STATE_KEYS[i];\n      var val = safeGet(key);\n      if (val !== null && val !== undefined) state[key] = val;\n    }\n    // Grab dynamic widget-*-enabled keys\n    try {\n      for (var j = 0; j < localStorage.length; j++) {\n        var k = localStorage.key(j);\n        if (/^widget-.+-enabled$/.test(k)) {\n          state[k] = localStorage.getItem(k);\n        }\n      }\n    } catch (e) { /* private browsing */ }\n    return state;\n  }\n\n  // Restore browser state from backup into localStorage\n  function restoreBrowserState(browserState) {\n    if (!browserState || typeof browserState !== 'object') return 0;\n    var count = 0;\n    for (var key in browserState) {\n      if (!browserState.hasOwnProperty(key)) continue;\n      safeSet(key, browserState[key]);\n      count++;\n    }\n    return count;\n  }\n\n  // Handle legacy v1.0.0 import-export format (pre-backup modal)\n  function isLegacyFormat(data) {\n    return data.version && !data.files && data.services;\n  }\n\n  function restoreLegacyFormat(data) {\n    // Map the old flat keys into browserState for localStorage restore\n    var browserState = {};\n    if (data.customServices) browserState['custom-services'] = JSON.stringify(data.customServices);\n    if (data.customApps) browserState['custom-apps'] = JSON.stringify(data.customApps);\n    if (data.weatherZip) browserState['weather-zip'] = data.weatherZip;\n    if (data.theme) browserState['theme'] = data.theme;\n    if (data.userThemes && Object.keys(data.userThemes).length) browserState['user-themes'] = JSON.stringify(data.userThemes);\n    restoreBrowserState(browserState);\n\n    // Push services to server if available\n    if (data.services && Array.isArray(data.services)) {\n      secureFetch('/api/v1/services', {\n        method: 'PUT',\n        headers: { 'Content-Type': 'application/json' },\n        body: JSON.stringify(data.services)\n      }).catch(function() {});\n    }\n\n    // Push themes to server if available\n    if (data.userThemes) {\n      Object.keys(data.userThemes).forEach(function(slug) {\n        var t = data.userThemes[slug];\n        var colors = {};\n        (window.THEME_PROPS || []).forEach(function(p) { if (t[p]) colors[p] = t[p]; });\n        secureFetch('/api/v1/themes/' + slug, {\n          method: 'POST',\n          headers: { 'Content-Type': 'application/json' },\n          body: JSON.stringify({ name: t.name || slug, colors: colors })\n        }).catch(function() {});\n      });\n    }\n  }\n\n  // Inject modal HTML\n  injectModal('backup-modal', `<div id=\"backup-modal\" class=\"weather-modal\">\n    <div class=\"weather-modal-content\" style=\"min-width: 550px; max-width: 650px;\">\n      <h3>\uD83D\uDCBE Backup & Restore</h3>\n      <p class=\"modal-subtitle\">\n        Full backup of your entire DashCaddy setup \u2014 server config, credentials, themes, and browser preferences in one file.\n      </p>\n\n      <!-- Tab bar -->\n      <div class=\"panel-tabs\">\n        <button class=\"panel-tab active\" data-panel=\"backup-manual\">Manual</button>\n        <button class=\"panel-tab\" data-panel=\"backup-schedules-tab\">Schedules</button>\n        <button class=\"panel-tab\" data-panel=\"backup-disk-tab\">Backups on Disk</button>\n        <button class=\"panel-tab\" data-panel=\"backup-pointintime-tab\">Point-in-Time</button>\n        <button class=\"panel-tab\" data-panel=\"backup-history-tab\">History</button>\n      </div>\n\n      <!-- Tab: Manual -->\n      <div id=\"backup-manual\" class=\"panel-section active\">\n        <!-- Export Section -->\n        <div style=\"margin-bottom: 20px; padding: 16px; background: linear-gradient(135deg, color-mix(in srgb, #27ae60 15%, transparent), color-mix(in srgb, #2ecc71 10%, transparent)); border-radius: 10px; border: 1px solid #27ae60;\">\n          <h4 style=\"margin: 0 0 8px; color: #2ecc71; font-size: 0.95rem;\">\uD83D\uDCE4 Export Backup</h4>\n          <p style=\"font-size: 0.8rem; color: var(--muted); margin: 0 0 12px;\">\n            Downloads everything \u2014 services, Caddyfile, credentials, encryption key, themes, and all browser preferences.\n          </p>\n          <button id=\"backup-export-btn\" style=\"width: 100%; padding: 10px; background: linear-gradient(135deg, #27ae60 0%, #2ecc71 100%); border: none; color: white; font-weight: 600; border-radius: 8px; cursor: pointer;\">\n            \u2B07\uFE0F Download Full Backup\n          </button>\n        </div>\n\n        <!-- Import Section -->\n        <div style=\"padding: 16px; background: linear-gradient(135deg, color-mix(in srgb, #3498db 15%, transparent), color-mix(in srgb, #2980b9 10%, transparent)); border-radius: 10px; border: 1px solid #3498db;\">\n          <h4 style=\"margin: 0 0 8px; color: #3498db; font-size: 0.95rem;\">\uD83D\uDCE5 Restore Backup</h4>\n          <p style=\"font-size: 0.8rem; color: var(--muted); margin: 0 0 12px;\">\n            Upload a backup file to restore your entire configuration \u2014 drag and drop ready.\n          </p>\n          <input type=\"file\" id=\"backup-file-input\" accept=\".json\" style=\"display: none;\" />\n          <button id=\"backup-select-file\" style=\"width: 100%; padding: 10px; background: linear-gradient(135deg, #3498db 0%, #2980b9 100%); border: none; color: white; font-weight: 600; border-radius: 8px; cursor: pointer;\">\n            \uD83D\uDCC1 Select Backup File\n          </button>\n          <div id=\"backup-file-name\" style=\"display: none; margin-top: 8px; padding: 8px; background: var(--card-base); border-radius: 6px; font-size: 0.85rem;\"></div>\n        </div>\n\n        <!-- Preview Section (shown after file selected) -->\n        <div id=\"backup-preview\" style=\"display: none; margin-top: 16px; padding: 16px; background: var(--card-base); border-radius: 10px; border: 1px solid var(--border);\">\n          <h4 style=\"margin: 0 0 12px; font-size: 0.9rem;\">\uD83D\uDCCB Backup Contents</h4>\n          <div id=\"backup-preview-content\" style=\"font-size: 0.85rem;\"></div>\n          <div style=\"margin-top: 12px; padding-top: 12px; border-top: 1px solid var(--border);\">\n            <label class=\"checkbox-label\" style=\"font-size: 0.85rem;\">\n              <input type=\"checkbox\" id=\"backup-reload-caddy\" checked />\n              Reload Caddy after restore\n            </label>\n          </div>\n          <button id=\"backup-do-restore-btn\" style=\"width: 100%; margin-top: 12px; padding: 10px; background: linear-gradient(135deg, #e74c3c 0%, #c0392b 100%); border: none; color: white; font-weight: 600; border-radius: 8px; cursor: pointer;\">\n            \u26A1 Restore Everything\n          </button>\n        </div>\n\n        <!-- Result Message -->\n        <div id=\"backup-result\" style=\"display: none; margin-top: 16px; padding: 12px; border-radius: 8px;\"></div>\n      </div>\n\n      <!-- Tab: Schedules (Premium) -->\n      <div id=\"backup-schedules-tab\" class=\"panel-section\">\n        <div id=\"backup-schedules-container\">\n          <div class=\"panel-empty\">\n            <span class=\"empty-icon\">\u23F0</span>\n            <span class=\"brand-spinner\"></span> Loading schedules...\n          </div>\n        </div>\n      </div>\n\n      <!-- Tab: Backups on Disk -->\n      <div id=\"backup-disk-tab\" class=\"panel-section\">\n        <div id=\"backup-disk-container\">\n          <div class=\"panel-empty\">\n            <span class=\"empty-icon\">\uD83D\uDCBE</span>\n            <span class=\"brand-spinner\"></span> Loading backup files...\n          </div>\n        </div>\n      </div>\n\n      <!-- Tab: Point-in-Time Restore -->\n      <div id=\"backup-pointintime-tab\" class=\"panel-section\">\n        <div id=\"pointintime-container\">\n          <div class=\"panel-empty\">\n            <span class=\"empty-icon\">\u23EA</span>\n            <span class=\"brand-spinner\"></span> Loading...\n          </div>\n        </div>\n      </div>\n\n      <!-- Tab: Backup History -->\n      <div id=\"backup-history-tab\" class=\"panel-section\">\n        <div id=\"backup-history-container\" style=\"max-height: 400px; overflow-y: auto;\">\n          <div class=\"panel-empty\">\n            <span class=\"empty-icon\">\uD83D\uDCCB</span>\n            <span class=\"brand-spinner\"></span> Loading backup history...\n          </div>\n        </div>\n      </div>\n\n      <!-- Close Button -->\n      <div class=\"weather-modal-buttons modal-footer-bar\">\n        <button id=\"backup-cancel\">Close</button>\n      </div>\n    </div>\n  </div>`);\n\n  var modal = document.getElementById('backup-modal');\n  var openBtn = document.getElementById('backup-restore-btn');\n  var cancelBtn = document.getElementById('backup-cancel');\n  var exportBtn = document.getElementById('backup-export-btn');\n  var selectFileBtn = document.getElementById('backup-select-file');\n  var fileInput = document.getElementById('backup-file-input');\n  var fileNameDiv = document.getElementById('backup-file-name');\n  var previewDiv = document.getElementById('backup-preview');\n  var previewContent = document.getElementById('backup-preview-content');\n  var restoreBtn = document.getElementById('backup-do-restore-btn');\n  var resultDiv = document.getElementById('backup-result');\n  var scheduleContainer = document.getElementById('backup-schedules-container');\n  var historyContainer = document.getElementById('backup-history-container');\n  var diskContainer = document.getElementById('backup-disk-container');\n  var pointintimeContainer = document.getElementById('pointintime-container');\n\n  var selectedBackup = null;\n\n  // Open modal\n  openBtn?.addEventListener('click', function() {\n    modal.classList.add('show');\n    if (resultDiv) resultDiv.style.display = 'none';\n    if (previewDiv) previewDiv.style.display = 'none';\n    if (fileNameDiv) fileNameDiv.style.display = 'none';\n    selectedBackup = null;\n  });\n\n  wireModal(modal, cancelBtn);\n\n  // === EXPORT: Server backup + browser state in one file ===\n  exportBtn?.addEventListener('click', async function() {\n    exportBtn.disabled = true;\n    exportBtn.innerHTML = '<span class=\"brand-spinner\"></span> Exporting...';\n    try {\n      // Fetch server-side backup (config, services, caddyfile, credentials, encryption key, themes, etc.)\n      var response = await fetch('/api/v1/backup/export');\n      var data = await response.json();\n\n      // Add all browser localStorage state\n      data.browserState = collectBrowserState();\n\n      // Download unified backup\n      var blob = new Blob([JSON.stringify(data, null, 2)], { type: 'application/json' });\n      var url = URL.createObjectURL(blob);\n      var a = document.createElement('a');\n      a.href = url;\n      a.download = 'dashcaddy-backup-' + new Date().toISOString().split('T')[0] + '.json';\n      document.body.appendChild(a);\n      a.click();\n      document.body.removeChild(a);\n      URL.revokeObjectURL(url);\n\n      var stateCount = Object.keys(data.browserState).length;\n      var themeCount = data.themes ? Object.keys(data.themes).length : 0;\n      resultDiv.innerHTML = '\u2705 Full backup downloaded \u2014 server config + ' + stateCount + ' browser settings' + (themeCount ? ' + ' + themeCount + ' themes' : '');\n      resultDiv.style.display = 'block';\n      resultDiv.style.background = 'color-mix(in srgb, var(--ok-fg) 15%, transparent)';\n      resultDiv.style.border = '1px solid var(--ok-fg)';\n    } catch (e) {\n      resultDiv.innerHTML = '\u274C Export failed: ' + escapeHtml(e.message);\n      resultDiv.style.display = 'block';\n      resultDiv.style.background = 'color-mix(in srgb, var(--bad-fg) 15%, transparent)';\n      resultDiv.style.border = '1px solid var(--bad-fg)';\n    }\n    exportBtn.disabled = false;\n    exportBtn.innerHTML = '\u2B07\uFE0F Download Full Backup';\n  });\n\n  // Select file button\n  selectFileBtn?.addEventListener('click', function() { fileInput.click(); });\n\n  // === FILE SELECTED: Preview contents ===\n  fileInput?.addEventListener('change', async function(e) {\n    var file = e.target.files[0];\n    if (!file) return;\n    fileNameDiv.textContent = '\uD83D\uDCC4 ' + file.name;\n    fileNameDiv.style.display = 'block';\n    resultDiv.style.display = 'none';\n    try {\n      var text = await file.text();\n      var backup = JSON.parse(text);\n\n      // Handle legacy v1.0.0 format (from old import-export.js)\n      if (isLegacyFormat(backup)) {\n        selectedBackup = backup;\n        var html = '<div style=\"margin-bottom: 8px; color: var(--muted); font-size: 0.8rem;\">Legacy format (v' + escapeHtml(backup.version) + ')</div>';\n        html += '<div style=\"display: flex; flex-wrap: wrap; gap: 6px;\">';\n        if (backup.services?.length) html += '<span style=\"padding: 4px 8px; background: var(--base); border-radius: 4px; font-size: 0.8rem;\">\uD83D\uDCCB ' + backup.services.length + ' services</span>';\n        if (backup.customApps?.length) html += '<span style=\"padding: 4px 8px; background: var(--base); border-radius: 4px; font-size: 0.8rem;\">\uD83D\uDCE6 ' + backup.customApps.length + ' custom apps</span>';\n        if (backup.theme) html += '<span style=\"padding: 4px 8px; background: var(--base); border-radius: 4px; font-size: 0.8rem;\">\uD83C\uDFA8 Theme: ' + escapeHtml(backup.theme) + '</span>';\n        if (backup.userThemes) html += '<span style=\"padding: 4px 8px; background: var(--base); border-radius: 4px; font-size: 0.8rem;\">\uD83C\uDFA8 ' + Object.keys(backup.userThemes).length + ' custom themes</span>';\n        html += '</div>';\n        previewContent.innerHTML = html;\n        previewDiv.style.display = 'block';\n        return;\n      }\n\n      // v1.1+ / v2.0 format \u2014 send to server for preview\n      var response = await secureFetch('/api/v1/backup/preview', {\n        method: 'POST',\n        headers: { 'Content-Type': 'application/json' },\n        body: JSON.stringify(backup)\n      });\n      var preview = await response.json();\n      if (preview.success) {\n        selectedBackup = backup;\n        var html = '<div style=\"margin-bottom: 8px; color: var(--muted); font-size: 0.8rem;\">Exported: ' + new Date(backup.exportedAt).toLocaleString() + ' (v' + escapeHtml(backup.version) + ')</div>';\n\n        // Server files\n        html += '<div style=\"margin-bottom: 6px; font-size: 0.75rem; color: var(--muted); text-transform: uppercase; letter-spacing: 0.5px;\">Server Config</div>';\n        html += '<div style=\"display: flex; flex-wrap: wrap; gap: 6px; margin-bottom: 10px;\">';\n        for (var key in preview.preview.files) {\n          var info = preview.preview.files[key];\n          var icon = info.action === 'create' ? '\uD83C\uDD95' : '\uD83D\uDCDD';\n          html += '<span style=\"padding: 4px 8px; background: var(--base); border-radius: 4px; font-size: 0.8rem;\">' + icon + ' ' + escapeHtml(info.description) + '</span>';\n        }\n        html += '</div>';\n\n        // Services count\n        if (preview.preview.serviceCount) {\n          html += '<div style=\"font-size: 0.8rem; color: var(--accent); margin-bottom: 6px;\">' + preview.preview.serviceCount + ' services</div>';\n        }\n\n        // Themes\n        if (preview.preview.themeCount) {\n          html += '<div style=\"font-size: 0.8rem; color: var(--accent); margin-bottom: 6px;\">\uD83C\uDFA8 ' + preview.preview.themeCount + ' custom themes</div>';\n        }\n\n        // Browser state\n        if (preview.preview.browserStateCount) {\n          html += '<div style=\"margin-top: 6px; font-size: 0.75rem; color: var(--muted); text-transform: uppercase; letter-spacing: 0.5px;\">Browser Preferences</div>';\n          html += '<div style=\"font-size: 0.8rem; color: var(--accent);\">\uD83D\uDDA5\uFE0F ' + preview.preview.browserStateCount + ' saved settings (theme, weather, clock, widgets, etc.)</div>';\n        }\n\n        previewContent.innerHTML = html;\n        previewDiv.style.display = 'block';\n      } else {\n        resultDiv.innerHTML = '\u26A0\uFE0F Invalid backup file: ' + escapeHtml(preview.error);\n        resultDiv.style.display = 'block';\n        resultDiv.style.background = 'color-mix(in srgb, #f39c12 15%, transparent)';\n        resultDiv.style.border = '1px solid #f39c12';\n        previewDiv.style.display = 'none';\n      }\n    } catch (e) {\n      resultDiv.innerHTML = '\u274C Could not read file: ' + escapeHtml(e.message);\n      resultDiv.style.display = 'block';\n      resultDiv.style.background = 'color-mix(in srgb, var(--bad-fg) 15%, transparent)';\n      resultDiv.style.border = '1px solid var(--bad-fg)';\n      previewDiv.style.display = 'none';\n    }\n  });\n\n  // === RESTORE: Server + browser state ===\n  restoreBtn?.addEventListener('click', async function() {\n    if (!selectedBackup) return;\n    if (!confirm('This will overwrite your current configuration and browser preferences. Continue?')) return;\n    restoreBtn.disabled = true;\n    restoreBtn.innerHTML = '<span class=\"brand-spinner\"></span> Restoring...';\n    try {\n      // Handle legacy format\n      if (isLegacyFormat(selectedBackup)) {\n        restoreLegacyFormat(selectedBackup);\n        resultDiv.innerHTML = '\u2705 Legacy backup restored \u2014 browser settings and services imported.';\n        resultDiv.style.background = 'color-mix(in srgb, var(--ok-fg) 15%, transparent)';\n        resultDiv.style.border = '1px solid var(--ok-fg)';\n        resultDiv.style.display = 'block';\n        setTimeout(function() { location.reload(); }, 2000);\n        restoreBtn.disabled = false;\n        restoreBtn.innerHTML = '\u26A1 Restore Everything';\n        return;\n      }\n\n      // v1.1+ / v2.0 \u2014 restore server-side first\n      var reloadCaddy = document.getElementById('backup-reload-caddy')?.checked ?? true;\n      var response = await secureFetch('/api/v1/backup/restore', {\n        method: 'POST',\n        headers: { 'Content-Type': 'application/json' },\n        body: JSON.stringify({ backup: selectedBackup, options: { reloadCaddy: reloadCaddy } })\n      });\n      var data = await response.json();\n\n      // Then restore browser state\n      var browserCount = 0;\n      if (selectedBackup.browserState) {\n        browserCount = restoreBrowserState(selectedBackup.browserState);\n      }\n\n      if (data.success) {\n        var msg = '\u2705 ' + data.message;\n        if (browserCount > 0) msg += '<br><small style=\"color: var(--muted);\">' + browserCount + ' browser settings restored</small>';\n        if (data.results.caddyReloaded) msg += '<br><small style=\"color: var(--muted);\">Caddy configuration reloaded</small>';\n        resultDiv.innerHTML = msg;\n        resultDiv.style.background = 'color-mix(in srgb, var(--ok-fg) 15%, transparent)';\n        resultDiv.style.border = '1px solid var(--ok-fg)';\n        setTimeout(function() { location.reload(); }, 2000);\n      } else {\n        resultDiv.innerHTML = '\u26A0\uFE0F ' + escapeHtml(data.message);\n        if (browserCount > 0) resultDiv.innerHTML += '<br><small style=\"color: var(--muted);\">' + browserCount + ' browser settings were restored</small>';\n        if (data.results?.errors?.length > 0) {\n          resultDiv.innerHTML += '<br><small>' + data.results.errors.map(function(e) { return escapeHtml(e.file) + ': ' + escapeHtml(e.error); }).join(', ') + '</small>';\n        }\n        resultDiv.style.background = 'color-mix(in srgb, #f39c12 15%, transparent)';\n        resultDiv.style.border = '1px solid #f39c12';\n      }\n      resultDiv.style.display = 'block';\n    } catch (e) {\n      resultDiv.innerHTML = '\u274C Restore failed: ' + escapeHtml(e.message);\n      resultDiv.style.display = 'block';\n      resultDiv.style.background = 'color-mix(in srgb, var(--bad-fg) 15%, transparent)';\n      resultDiv.style.border = '1px solid var(--bad-fg)';\n    }\n    restoreBtn.disabled = false;\n    restoreBtn.innerHTML = '\u26A1 Restore Everything';\n  });\n\n  // === Schedules Tab (Premium) ===\n  async function loadSchedulesTab() {\n    if (!scheduleContainer) return;\n    scheduleContainer.innerHTML = '<div class=\"panel-empty\"><span class=\"brand-spinner\"></span> Loading...</div>';\n    try {\n      var res = await fetch('/api/v1/backups/schedule');\n      var data = await res.json();\n      \n      if (data.premiumRequired) {\n        scheduleContainer.innerHTML = '<div class=\"panel-empty\" style=\"padding: 24px; text-align: center;\">' +\n          '<div style=\"font-size: 2rem; margin-bottom: 12px;\">\u2B50</div>' +\n          '<div style=\"font-weight: 600; margin-bottom: 8px;\">Premium Feature</div>' +\n          '<div style=\"font-size: 0.85rem; color: var(--muted);\">Auto-backup scheduling requires a DashCaddy Premium subscription.</div>' +\n          '<button onclick=\"showNotification(\\'Upgrade to Premium to enable auto-backups!\\', \\'info\\'); scrollToSection(\\'license\\');\" style=\"margin-top: 16px; padding: 8px 20px; background: linear-gradient(135deg, #f39c12, #e67e22); border: none; color: white; border-radius: 8px; cursor: pointer; font-weight: 600;\">Upgrade to Premium</button>' +\n          '</div>';\n        return;\n      }\n      \n      if (!data.success) throw new Error(data.error || 'Failed to load schedules');\n      \n      var schedules = data.schedules || [];\n      \n      if (schedules.length === 0) {\n        scheduleContainer.innerHTML = '<div class=\"panel-empty\">' +\n          '<span class=\"empty-icon\">\u23F0</span>' +\n          '<div>No backup schedules configured</div>' +\n          '<div style=\"font-size: 0.8rem; color: var(--muted); margin-top: 4px;\">Select apps below to enable auto-backup</div>' +\n          '</div>';\n        return;\n      }\n      \n      var html = '<div style=\"display: flex; flex-direction: column; gap: 8px;\">';\n      for (var i = 0; i < schedules.length; i++) {\n        var sch = schedules[i];\n        var nextRunStr = sch.nextRun ? new Date(sch.nextRun).toLocaleString() : 'Not scheduled';\n        var lastRunStr = sch.lastRun ? new Date(sch.lastRun).toLocaleString() : 'Never';\n        \n        html += '<div style=\"padding: 12px 14px; background: var(--card-base); border-radius: 8px; border: 1px solid var(--border);\">' +\n          '<div style=\"display: flex; justify-content: space-between; align-items: center; margin-bottom: 8px;\">' +\n          '  <div style=\"font-weight: 600; font-size: 0.9rem;\">' + escapeHtml(sch.appId) + '</div>' +\n          '  <label class=\"toggle-switch\" style=\"display: flex; align-items: center; gap: 6px;\">' +\n          '    <input type=\"checkbox\" class=\"schedule-toggle\" data-appid=\"' + escapeHtml(sch.appId) + '\"' + (sch.enabled ? ' checked' : '') + ' />' +\n          '    <span style=\"font-size: 0.75rem; color: var(--muted);\">' + (sch.enabled ? 'ON' : 'OFF') + '</span>' +\n          '  </label>' +\n          '</div>' +\n          '<div style=\"display: grid; grid-template-columns: 1fr 1fr; gap: 8px; font-size: 0.8rem; margin-bottom: 10px;\">' +\n          '  <div><span style=\"color: var(--muted);\">Schedule:</span> <select class=\"schedule-select\" data-appid=\"' + escapeHtml(sch.appId) + '\" style=\"background: var(--base); border: 1px solid var(--border); border-radius: 4px; padding: 2px 6px;\">' +\n          '    <option value=\"hourly\"' + (sch.schedule === 'hourly' ? ' selected' : '') + '>Hourly</option>' +\n          '    <option value=\"daily\"' + (sch.schedule === 'daily' ? ' selected' : '') + '>Daily</option>' +\n          '    <option value=\"weekly\"' + (sch.schedule === 'weekly' ? ' selected' : '') + '>Weekly</option>' +\n          '    <option value=\"monthly\"' + (sch.schedule === 'monthly' ? ' selected' : '') + '>Monthly</option>' +\n          '  </select></div>' +\n          '  <div><span style=\"color: var(--muted);\">Keep last:</span> <input type=\"number\" class=\"retention-input\" data-appid=\"' + escapeHtml(sch.appId) + '\" value=\"' + (sch.retention?.keep || 7) + '\" min=\"1\" max=\"100\" style=\"width: 50px; background: var(--base); border: 1px solid var(--border); border-radius: 4px; padding: 2px 6px;\" /></div>' +\n          '</div>' +\n          '<div style=\"font-size: 0.75rem; color: var(--muted); margin-bottom: 10px;\">' +\n          '  <div>Next run: ' + escapeHtml(nextRunStr) + '</div>' +\n          '  <div>Last run: ' + escapeHtml(lastRunStr) + '</div>' +\n          '</div>' +\n          '<div style=\"display: flex; gap: 6px;\">' +\n          '  <button class=\"schedule-run-now\" data-appid=\"' + escapeHtml(sch.appId) + '\" style=\"padding: 5px 12px; font-size: 0.8rem; background: color-mix(in srgb, var(--ok-fg) 20%, transparent); border: 1px solid var(--ok-fg); color: var(--ok-fg); border-radius: 6px; cursor: pointer;\">\u25B6\uFE0F Run Now</button>' +\n          '  <button class=\"schedule-delete\" data-appid=\"' + escapeHtml(sch.appId) + '\" style=\"padding: 5px 12px; font-size: 0.8rem; background: transparent; border: 1px solid var(--bad-fg); color: var(--bad-fg); border-radius: 6px; cursor: pointer;\">\uD83D\uDDD1\uFE0F Remove</button>' +\n          '</div>' +\n          '</div>';\n      }\n      html += '</div>';\n      \n      // Add \"Add Schedule\" section at bottom\n      html += '<div style=\"margin-top: 16px; padding: 16px; background: color-mix(in srgb, var(--accent) 5%, transparent); border-radius: 10px; border: 1px dashed var(--border);\">' +\n        '<h4 style=\"margin: 0 0 12px; font-size: 0.85rem; color: var(--muted);\">\u2795 Add New Schedule</h4>' +\n        '<div style=\"display: flex; gap: 8px; flex-wrap: wrap;\">' +\n        '  <input type=\"text\" id=\"new-schedule-appid\" placeholder=\"App ID (e.g., plex, sonarr)\" style=\"flex: 1; min-width: 150px; padding: 8px; border-radius: 6px; border: 1px solid var(--border); background: var(--base);\" />' +\n        '  <select id=\"new-schedule-interval\" style=\"padding: 8px; border-radius: 6px; border: 1px solid var(--border); background: var(--base);\">' +\n        '    <option value=\"hourly\">Hourly</option>' +\n        '    <option value=\"daily\" selected>Daily</option>' +\n        '    <option value=\"weekly\">Weekly</option>' +\n        '    <option value=\"monthly\">Monthly</option>' +\n        '    <option value=\"6h\">Every 6 hours</option>' +\n        '    <option value=\"30m\">Every 30 minutes</option>' +\n        '  </select>' +\n        '  <input type=\"number\" id=\"new-schedule-retention\" value=\"7\" min=\"1\" max=\"100\" placeholder=\"Keep\" style=\"width: 70px; padding: 8px; border-radius: 6px; border: 1px solid var(--border); background: var(--base);\" />' +\n        '  <button id=\"add-schedule-btn\" style=\"padding: 8px 16px; background: var(--accent); border: none; color: white; border-radius: 6px; cursor: pointer; font-weight: 500;\">Add Schedule</button>' +\n        '</div>' +\n        '</div>';\n      \n      scheduleContainer.innerHTML = html;\n      \n      // Wire up event listeners\n      scheduleContainer.querySelectorAll('.schedule-toggle').forEach(function(toggle) {\n        toggle.addEventListener('change', function() { updateSchedule(toggle.dataset.appid, { enabled: toggle.checked }); });\n      });\n      scheduleContainer.querySelectorAll('.schedule-select').forEach(function(sel) {\n        sel.addEventListener('change', function() { updateSchedule(sel.dataset.appid, { schedule: sel.value }); });\n      });\n      scheduleContainer.querySelectorAll('.retention-input').forEach(function(inp) {\n        inp.addEventListener('change', function() { updateSchedule(inp.dataset.appid, { retention: { keep: parseInt(inp.value) || 7 } }); });\n      });\n      scheduleContainer.querySelectorAll('.schedule-run-now').forEach(function(btn) {\n        btn.addEventListener('click', function() { runBackupNow(btn.dataset.appid); });\n      });\n      scheduleContainer.querySelectorAll('.schedule-delete').forEach(function(btn) {\n        btn.addEventListener('click', function() { deleteSchedule(btn.dataset.appid); });\n      });\n      document.getElementById('add-schedule-btn')?.addEventListener('click', addNewSchedule);\n      \n    } catch (e) {\n      scheduleContainer.innerHTML = '<div class=\"panel-empty\" style=\"color: var(--bad-fg);\">Failed to load: ' + escapeHtml(e.message) + '</div>';\n    }\n  }\n  \n  async function updateSchedule(appId, updates) {\n    try {\n      var res = await secureFetch('/api/v1/backups/schedule', {\n        method: 'POST',\n        headers: { 'Content-Type': 'application/json' },\n        body: JSON.stringify({ appId, ...updates })\n      });\n      var data = await res.json();\n      if (data.success) {\n        showNotification('Schedule updated for ' + appId, 'success');\n      } else {\n        showNotification('Update failed: ' + (data.error || 'Unknown'), 'error');\n        loadSchedulesTab(); // Refresh on failure\n      }\n    } catch (e) {\n      showNotification('Error: ' + e.message, 'error');\n    }\n  }\n  \n  async function runBackupNow(appId) {\n    try {\n      var res = await secureFetch('/api/v1/backups/backup/' + encodeURIComponent(appId), {\n        method: 'POST',\n        headers: { 'Content-Type': 'application/json' }\n      });\n      var data = await res.json();\n      if (data.success) {\n        showNotification('Backup started for ' + appId + '!', 'success');\n      } else {\n        showNotification('Backup failed: ' + (data.error || 'Unknown'), 'error');\n      }\n    } catch (e) {\n      showNotification('Error: ' + e.message, 'error');\n    }\n  }\n  \n  async function deleteSchedule(appId) {\n    if (!confirm('Remove backup schedule for ' + appId + '?')) return;\n    try {\n      var res = await secureFetch('/api/v1/backups/schedule/' + encodeURIComponent(appId), { method: 'DELETE' });\n      var data = await res.json();\n      if (data.success) {\n        showNotification('Schedule removed for ' + appId, 'success');\n        loadSchedulesTab();\n      } else {\n        showNotification('Delete failed: ' + (data.error || 'Unknown'), 'error');\n      }\n    } catch (e) {\n      showNotification('Error: ' + e.message, 'error');\n    }\n  }\n  \n  async function addNewSchedule() {\n    var appId = document.getElementById('new-schedule-appid')?.value?.trim();\n    var interval = document.getElementById('new-schedule-interval')?.value || 'daily';\n    var retention = parseInt(document.getElementById('new-schedule-retention')?.value) || 7;\n    \n    if (!appId) {\n      showNotification('Please enter an App ID', 'warning');\n      return;\n    }\n    \n    try {\n      var res = await secureFetch('/api/v1/backups/schedule', {\n        method: 'POST',\n        headers: { 'Content-Type': 'application/json' },\n        body: JSON.stringify({ appId, schedule: interval, retention: { keep: retention }, enabled: true })\n      });\n      var data = await res.json();\n      if (data.success) {\n        showNotification('Schedule created for ' + appId, 'success');\n        loadSchedulesTab();\n        // Clear inputs\n        var appIdInput = document.getElementById('new-schedule-appid');\n        if (appIdInput) appIdInput.value = '';\n      } else {\n        showNotification('Failed: ' + (data.error || 'Unknown'), 'error');\n      }\n    } catch (e) {\n      showNotification('Error: ' + e.message, 'error');\n    }\n  }\n  \n  // === Backups on Disk Tab ===\n  async function loadDiskBackups() {\n    if (!diskContainer) return;\n    diskContainer.innerHTML = '<div class=\"panel-empty\"><span class=\"brand-spinner\"></span> Loading...</div>';\n    try {\n      var res = await fetch('/api/v1/backups/files');\n      var data = await res.json();\n      if (!data.success) throw new Error(data.error || 'Failed to load');\n\n      var files = data.files || [];\n\n      if (files.length === 0) {\n        diskContainer.innerHTML = '<div class=\"panel-empty\">' +\n          '<span class=\"empty-icon\">\uD83D\uDCBE</span>' +\n          '<div>No backup files on disk</div>' +\n          '<div style=\"font-size: 0.8rem; color: var(--muted); margin-top: 4px;\">Run a backup to create backup files</div>' +\n          '</div>';\n        return;\n      }\n\n      // Group by appId\n      var byApp = {};\n      for (var i = 0; i < files.length; i++) {\n        var f = files[i];\n        var appId = f.appId || 'unknown';\n        if (!byApp[appId]) byApp[appId] = [];\n        byApp[appId].push(f);\n      }\n\n      var html = '<div style=\"font-size: 0.75rem; color: var(--muted); margin-bottom: 12px;\">' + files.length + ' backup file(s) across ' + Object.keys(byApp).length + ' app(s)</div>';\n      html += '<div style=\"display: flex; flex-direction: column; gap: 12px;\">';\n\n      var appIds = Object.keys(byApp).sort();\n      for (var a = 0; a < appIds.length; a++) {\n        var appId = appIds[a];\n        var appFiles = byApp[appId];\n        html += '<div style=\"background: var(--card-base); border-radius: 8px; border: 1px solid var(--border); overflow: hidden;\">' +\n          '<div style=\"padding: 8px 12px; background: color-mix(in srgb, var(--accent) 8%, transparent); border-bottom: 1px solid var(--border); font-weight: 600; font-size: 0.85rem;\">' +\n          escapeHtml(appId) + ' <span style=\"font-weight: normal; color: var(--muted); font-size: 0.75rem;\">(' + appFiles.length + ' backup(s))</span>' +\n          '</div>';\n\n        for (var j = 0; j < appFiles.length; j++) {\n          var f = appFiles[j];\n          var dateStr = new Date(f.timestamp).toLocaleString();\n          html += '<div style=\"padding: 10px 12px; border-bottom: 1px solid var(--border);\">' +\n            '<div style=\"display: flex; justify-content: space-between; align-items: center; margin-bottom: 4px;\">' +\n            '  <div style=\"font-weight: 500; font-size: 0.85rem;\">' + escapeHtml(f.name) + '</div>' +\n            '  <div style=\"font-size: 0.75rem; color: var(--muted);\">' + f.sizeFormatted + '</div>' +\n            '</div>' +\n            '<div style=\"font-size: 0.75rem; color: var(--muted); margin-bottom: 8px;\">' + dateStr + '</div>' +\n            '<div style=\"display: flex; gap: 6px;\">' +\n            '  <button class=\"disk-compare-btn\" data-appid=\"' + escapeHtml(appId) + '\" data-filename=\"' + escapeHtml(f.name) + '\" style=\"padding: 3px 8px; font-size: 0.75rem; background: transparent; border: 1px solid var(--accent); color: var(--accent); border-radius: 5px; cursor: pointer;\">Compare</button>' +\n            '  <button class=\"disk-restore-btn\" data-appid=\"' + escapeHtml(appId) + '\" data-filename=\"' + escapeHtml(f.name) + '\" style=\"padding: 3px 8px; font-size: 0.75rem; background: linear-gradient(135deg, var(--ok-fg), #27ae60); border: none; color: white; border-radius: 5px; cursor: pointer; font-weight: 500;\">Restore</button>' +\n            '</div>' +\n            '</div>';\n        }\n        html += '</div>';\n      }\n      html += '</div>';\n\n      diskContainer.innerHTML = html;\n\n      // Wire up buttons\n      diskContainer.querySelectorAll('.disk-compare-btn').forEach(function(btn) {\n        btn.addEventListener('click', function() { compareBackupFile(btn.dataset.appid, btn.dataset.filename); });\n      });\n      diskContainer.querySelectorAll('.disk-restore-btn').forEach(function(btn) {\n        btn.addEventListener('click', function() { restoreBackupFile(btn.dataset.appid, btn.dataset.filename); });\n      });\n    } catch (e) {\n      diskContainer.innerHTML = '<div class=\"panel-empty\" style=\"color: var(--bad-fg);\">Failed: ' + escapeHtml(e.message) + '</div>';\n    }\n  }\n  \n  // === Backup History Tab ===\n  async function loadBackupHistory() {\n    if (!historyContainer) return;\n    historyContainer.innerHTML = '<div class=\"panel-empty\"><span class=\"brand-spinner\"></span> Loading...</div>';\n    try {\n      var res = await fetch('/api/v1/backups/history?limit=50');\n      var data = await res.json();\n      if (!data.success || !data.history?.length) {\n        historyContainer.innerHTML = '<div class=\"panel-empty\"><span class=\"empty-icon\">\uD83D\uDCCB</span> No backup history yet</div>';\n        return;\n      }\n      var html = '<div style=\"display: flex; flex-direction: column; gap: 6px;\">';\n      for (var i = 0; i < data.history.length; i++) {\n        var bk = data.history[i];\n        var sizeMB = bk.size ? (bk.size / 1024 / 1024).toFixed(2) : '?';\n        html += '<div style=\"padding: 10px 12px; background: var(--card-base); border-radius: 6px; border: 1px solid var(--border); font-size: 0.85rem;\">';\n        html += '  <div style=\"display: flex; justify-content: space-between; align-items: center; margin-bottom: 4px;\">';\n        html += '    <span style=\"font-weight: 500;\">' + escapeHtml(bk.name || 'backup') + '</span>';\n        html += '    <div style=\"display: flex; align-items: center; gap: 8px;\">';\n        html += '      <span class=\"status-badge ' + (bk.status === 'success' ? 'success' : 'down') + '\">' + escapeHtml(bk.status) + '</span>';\n        if (bk.status === 'success') html += '      <button class=\"backup-restore-btn\" data-backup-id=\"' + escapeHtml(bk.id) + '\" style=\"padding: 3px 8px; font-size: 0.75rem;\">Restore</button>';\n        html += '    </div>';\n        html += '  </div>';\n        html += '  <div style=\"font-size: 0.75rem; color: var(--muted);\">';\n        html += '    ' + new Date(bk.timestamp).toLocaleString() + ' | ' + sizeMB + ' MB | ' + (bk.duration ? (bk.duration / 1000).toFixed(1) + 's' : '--');\n        if (bk.encrypted) html += ' | \uD83D\uDD12';\n        html += '  </div>';\n        html += '</div>';\n      }\n      html += '</div>';\n      historyContainer.innerHTML = html;\n      historyContainer.querySelectorAll('.backup-restore-btn').forEach(function(btn) {\n        btn.addEventListener('click', function() { window.__restoreServerBackup(btn.dataset.backupId); });\n      });\n    } catch (e) {\n      historyContainer.innerHTML = '<div class=\"panel-empty\" style=\"color: var(--bad-fg);\">Failed: ' + escapeHtml(e.message) + '</div>';\n    }\n  }\n\n  window.__restoreServerBackup = async function(backupId) {\n    if (!confirm('Restore from this server backup? This will overwrite current configuration.')) return;\n    try {\n      var res = await secureFetch('/api/v1/backups/restore/' + backupId, {\n        method: 'POST',\n        headers: { 'Content-Type': 'application/json' },\n        body: JSON.stringify({ restoreServices: true, restoreConfig: true })\n      });\n      var data = await res.json();\n      if (data.success) {\n        showNotification('Restore completed successfully!', 'success');\n        location.reload();\n      } else {\n        showNotification('Restore failed: ' + (data.error || 'Unknown error'), 'error');\n      }\n    } catch (e) { showNotification('Restore error: ' + e.message, 'error'); }\n  };\n\n  // Lazy-load tabs\n  document.querySelector('[data-panel=\"backup-schedules-tab\"]')?.addEventListener('click', loadSchedulesTab);\n  document.querySelector('[data-panel=\"backup-disk-tab\"]')?.addEventListener('click', loadDiskBackups);\n  document.querySelector('[data-panel=\"backup-pointintime-tab\"]')?.addEventListener('click', loadPointInTimeTab);\n  document.querySelector('[data-panel=\"backup-history-tab\"]')?.addEventListener('click', loadBackupHistory);\n\n  // ===== Point-in-Time Restore Tab =====\n  async function loadPointInTimeTab() {\n    if (!pointintimeContainer) return;\n\n    // Check premium\n    try {\n      var licenseRes = await fetch('/api/v1/license/status');\n      var licenseData = await licenseRes.json();\n      if (licenseData.tier !== 'premium') {\n        pointintimeContainer.innerHTML = '<div class=\"panel-empty\" style=\"padding: 24px; text-align: center;\">' +\n          '<div style=\"font-size: 2rem; margin-bottom: 12px;\">\u2B50</div>' +\n          '<div style=\"font-weight: 600; margin-bottom: 8px;\">Premium Feature</div>' +\n          '<div style=\"font-size: 0.85rem; color: var(--muted);\">Point-in-time restore requires DashCaddy Premium with auto-backup enabled.</div>' +\n          '<button onclick=\"showNotification(\\'Upgrade to Premium for point-in-time restore!\\', \\'info\\'); scrollToSection(\\'license\\');\" style=\"margin-top: 16px; padding: 8px 20px; background: linear-gradient(135deg, #f39c12, #e67e22); border: none; color: white; border-radius: 8px; cursor: pointer; font-weight: 600;\">Upgrade to Premium</button>' +\n          '</div>';\n        return;\n      }\n    } catch (e) { /* ignore */ }\n\n    pointintimeContainer.innerHTML = '<div class=\"panel-empty\"><span class=\"brand-spinner\"></span> Loading...</div>';\n\n    try {\n      // Fetch services for dropdown\n      var servicesRes = await fetch('/api/v1/services');\n      var servicesData = await servicesRes.json();\n      var services = servicesData.services || [];\n\n      if (services.length === 0) {\n        pointintimeContainer.innerHTML = '<div class=\"panel-empty\"><span class=\"empty-icon\">\uD83D\uDCE6</span> No apps deployed yet</div>';\n        return;\n      }\n\n      var html = '<div style=\"padding: 8px 0 12px;\">' +\n        '<div style=\"display: flex; gap: 8px; align-items: center; margin-bottom: 12px;\">' +\n        '  <label style=\"font-size: 0.85rem; color: var(--muted); white-space: nowrap;\">App:</label>' +\n        '  <select id=\"pit-app-select\" style=\"flex: 1; padding: 8px; border-radius: 6px; border: 1px solid var(--border); background: var(--base); max-width: 240px;\">';\n      for (var i = 0; i < services.length; i++) {\n        html += '<option value=\"' + escapeHtml(services[i].id || services[i].name || '') + '\">' +\n          escapeHtml(services[i].name || services[i].id || '') + '</option>';\n      }\n      html += '</select>' +\n        '  <button id=\"pit-load-btn\" style=\"padding: 8px 16px; background: var(--accent); border: none; color: white; border-radius: 6px; cursor: pointer; font-weight: 500;\">Load Backups</button>' +\n        '</div>' +\n        '<div id=\"pit-backups-list\" style=\"max-height: 320px; overflow-y: auto;\"></div>' +\n        '</div>';\n\n      pointintimeContainer.innerHTML = html;\n\n      document.getElementById('pit-load-btn')?.addEventListener('click', function() {\n        var appId = document.getElementById('pit-app-select')?.value;\n        if (appId) loadPointInTimeBackups(appId);\n      });\n    } catch (e) {\n      pointintimeContainer.innerHTML = '<div class=\"panel-empty\" style=\"color: var(--bad-fg);\">Failed: ' + escapeHtml(e.message) + '</div>';\n    }\n  }\n\n  async function loadPointInTimeBackups(appId) {\n    var listEl = document.getElementById('pit-backups-list');\n    if (!listEl) return;\n\n    listEl.innerHTML = '<div style=\"padding: 20px; text-align: center;\"><span class=\"brand-spinner\"></span> Loading backups...</div>';\n\n    try {\n      var res = await fetch('/api/v1/backups/files/' + encodeURIComponent(appId));\n      var data = await res.json();\n\n      if (!data.success || !data.files || data.files.length === 0) {\n        listEl.innerHTML = '<div class=\"panel-empty\"><span class=\"empty-icon\">\uD83D\uDCBE</span> No backup files for ' + escapeHtml(appId) + '</div>';\n        return;\n      }\n\n      var html = '<div style=\"font-size: 0.75rem; color: var(--muted); margin-bottom: 8px;\">' + data.files.length + ' backup(s)</div>' +\n        '<div style=\"display: flex; flex-direction: column; gap: 6px;\">';\n\n      for (var i = 0; i < data.files.length; i++) {\n        var f = data.files[i];\n        var dateStr = new Date(f.timestamp).toLocaleString();\n        html += '<div style=\"padding: 10px 12px; background: var(--card-base); border-radius: 8px; border: 1px solid var(--border);\">' +\n          '<div style=\"display: flex; justify-content: space-between; align-items: center; margin-bottom: 4px;\">' +\n          '  <div style=\"font-weight: 500; font-size: 0.85rem;\">' + escapeHtml(f.name) + '</div>' +\n          '  <div style=\"font-size: 0.75rem; color: var(--muted);\">' + f.sizeFormatted + '</div>' +\n          '</div>' +\n          '<div style=\"font-size: 0.75rem; color: var(--muted); margin-bottom: 8px;\">' + dateStr + '</div>' +\n          '<div style=\"display: flex; gap: 6px;\">' +\n          '  <button class=\"pit-compare-btn\" data-appid=\"' + escapeHtml(appId) + '\" data-filename=\"' + escapeHtml(f.name) + '\" style=\"padding: 4px 10px; font-size: 0.75rem; background: transparent; border: 1px solid var(--accent); color: var(--accent); border-radius: 5px; cursor: pointer;\">Compare</button>' +\n          '  <button class=\"pit-restore-btn\" data-appid=\"' + escapeHtml(appId) + '\" data-filename=\"' + escapeHtml(f.name) + '\" style=\"padding: 4px 10px; font-size: 0.75rem; background: linear-gradient(135deg, var(--ok-fg), #27ae60); border: none; color: white; border-radius: 5px; cursor: pointer; font-weight: 500;\">Restore</button>' +\n          '</div>' +\n          '</div>';\n      }\n      html += '</div>';\n      listEl.innerHTML = html;\n\n      // Wire up buttons\n      listEl.querySelectorAll('.pit-compare-btn').forEach(function(btn) {\n        btn.addEventListener('click', function() { compareBackupFile(btn.dataset.appid, btn.dataset.filename); });\n      });\n      listEl.querySelectorAll('.pit-restore-btn').forEach(function(btn) {\n        btn.addEventListener('click', function() { restoreBackupFile(btn.dataset.appid, btn.dataset.filename); });\n      });\n    } catch (e) {\n      listEl.innerHTML = '<div class=\"panel-empty\" style=\"color: var(--bad-fg);\">Failed: ' + escapeHtml(e.message) + '</div>';\n    }\n  }\n\n  async function compareBackupFile(appId, filename) {\n    try {\n      var res = await secureFetch('/api/v1/backups/compare/' + encodeURIComponent(filename), {\n        method: 'POST',\n        headers: { 'Content-Type': 'application/json' },\n        body: JSON.stringify({})\n      });\n      var data = await res.json();\n      if (!data.success) {\n        showNotification('Compare failed: ' + (data.error || 'Unknown'), 'error');\n        return;\n      }\n\n      var diff = data.diff;\n      var html = '<div style=\"position: fixed; top: 0; left: 0; right: 0; bottom: 0; background: rgba(0,0,0,0.5); z-index: 10000; display: flex; align-items: center; justify-content: center;\" id=\"compare-overlay\">' +\n        '<div style=\"background: var(--base); border-radius: 12px; max-width: 600px; width: 90%; max-height: 80vh; overflow: auto; padding: 20px; border: 1px solid var(--border);\">' +\n        '<h4 style=\"margin: 0 0 16px;\">\uD83D\uDCCA Compare: ' + escapeHtml(filename) + '</h4>' +\n        '<div style=\"font-size: 0.8rem; color: var(--muted); margin-bottom: 16px;\">Size: ' + (diff.sizeFormatted || '?') + ' | Created: ' + new Date(diff.timestamp).toLocaleString() + '</div>';\n\n      if (diff.services) {\n        var svcChanged = diff.services.hasChanges ? '\uD83D\uDD34' : '\uD83D\uDFE2';\n        html += '<div style=\"margin-bottom: 12px; padding: 10px; background: var(--card-base); border-radius: 6px; border: 1px solid var(--border);\">' +\n          '<div style=\"font-weight: 600; font-size: 0.85rem; margin-bottom: 4px;\">' + svcChanged + ' Services (backup vs current)</div>' +\n          '<div style=\"font-size: 0.8rem; color: var(--muted);\">Backup: ' + diff.services.backupCount + ' services | Current: ' + diff.services.currentCount + ' services</div>';\n        if (diff.services.hasChanges) {\n          html += '<div style=\"margin-top: 6px; font-size: 0.8rem; color: #f39c12;\">Services differ \u2014 restoring will replace current configuration</div>';\n        }\n        html += '</div>';\n      }\n\n      if (diff.config) {\n        var cfgChanged = diff.config.hasChanges ? '\uD83D\uDD34' : '\uD83D\uDFE2';\n        html += '<div style=\"margin-bottom: 12px; padding: 10px; background: var(--card-base); border-radius: 6px; border: 1px solid var(--border);\">' +\n          '<div style=\"font-weight: 600; font-size: 0.85rem; margin-bottom: 4px;\">' + cfgChanged + ' Configuration</div>';\n        if (diff.config.hasChanges) {\n          html += '<div style=\"font-size: 0.8rem; color: #f39c12;\">Configuration differs \u2014 restoring will replace current settings</div>';\n        } else {\n          html += '<div style=\"font-size: 0.8rem; color: var(--ok-fg);\">No changes</div>';\n        }\n        html += '</div>';\n      }\n\n      html += '<button id=\"compare-close-btn\" style=\"padding: 8px 20px; background: var(--accent); border: none; color: white; border-radius: 6px; cursor: pointer; font-weight: 500;\">Close</button>' +\n        '</div></div>';\n\n      document.body.insertAdjacentHTML('beforeend', html);\n      document.getElementById('compare-close-btn')?.addEventListener('click', function() {\n        document.getElementById('compare-overlay')?.remove();\n      });\n      document.getElementById('compare-overlay')?.addEventListener('click', function(e) {\n        if (e.target === this) this.remove();\n      });\n    } catch (e) {\n      showNotification('Compare error: ' + e.message, 'error');\n    }\n  }\n\n  async function restoreBackupFile(appId, filename) {\n    if (!confirm('Restore ' + filename + ' for ' + appId + '?\\n\\nThis will replace current configuration, credentials, and data. Containers will be restarted.')) return;\n\n    try {\n      var res = await secureFetch('/api/v1/apps/' + encodeURIComponent(appId) + '/revert/' + encodeURIComponent(filename), {\n        method: 'POST',\n        headers: { 'Content-Type': 'application/json' },\n        body: JSON.stringify({ restartContainers: true })\n      });\n      var data = await res.json();\n      if (data.success) {\n        showNotification(appId + ' restored to ' + filename, 'success');\n        setTimeout(function() { location.reload(); }, 1500);\n      } else {\n        showNotification('Restore failed: ' + (data.error || 'Unknown'), 'error');\n      }\n    } catch (e) {\n      showNotification('Restore error: ' + e.message, 'error');\n    }\n  }\n})();\n;\n// ========== RESOURCE MONITOR (Enhanced) ==========\n(function() {\n  // Inject modal HTML\n  injectModal('stats-modal', `<div id=\"stats-modal\" class=\"weather-modal\">\n    <div class=\"weather-modal-content\" style=\"min-width: 750px; max-width: 950px;\">\n      <h3>\uD83D\uDCCA Resource Monitor</h3>\n      <p class=\"modal-subtitle\">\n        Real-time and historical CPU, memory, network, and disk usage for containers.\n      </p>\n\n      <!-- Tab bar -->\n      <div class=\"panel-tabs\">\n        <button class=\"panel-tab active\" data-panel=\"stats-live\">Live Stats</button>\n        <button class=\"panel-tab\" data-panel=\"stats-aggregated\">24h Summary</button>\n        <button class=\"panel-tab\" data-panel=\"stats-history\">History</button>\n        <button class=\"panel-tab\" data-panel=\"stats-alerts\">Alerts</button>\n      </div>\n\n      <!-- Tab: Live Stats -->\n      <div id=\"stats-live\" class=\"panel-section active\">\n        <div id=\"stats-container\" class=\"scroll-container\">\n          <div style=\"text-align: center; padding: 40px; color: var(--muted);\">\n            <span class=\"brand-spinner\"></span> Loading container stats...\n          </div>\n        </div>\n      </div>\n\n      <!-- Tab: 24h Aggregated Summary -->\n      <div id=\"stats-aggregated\" class=\"panel-section\">\n        <div id=\"stats-aggregated-container\" class=\"scroll-container\">\n          <div class=\"panel-empty\">\n            <span class=\"empty-icon\">\uD83D\uDCC8</span>\n            Loading 24-hour aggregated metrics...\n          </div>\n        </div>\n      </div>\n\n      <!-- Tab: Long-term History -->\n      <div id=\"stats-history\" class=\"panel-section\">\n        <div style=\"display: flex; gap: 8px; align-items: center; margin-bottom: 12px; flex-wrap: wrap;\">\n          <label style=\"font-size: 0.85rem; color: var(--muted);\">Container:</label>\n          <select id=\"stats-history-container\" style=\"padding: 4px 8px; background: var(--card-base); border: 1px solid var(--border); color: var(--fg); border-radius: 4px; font-size: 0.85rem; flex: 1; min-width: 180px;\"></select>\n          <div id=\"stats-history-range-buttons\" style=\"display: flex; gap: 4px;\">\n            <button class=\"stats-range-btn active\" data-range=\"1h\">1h</button>\n            <button class=\"stats-range-btn\" data-range=\"24h\">24h</button>\n            <button class=\"stats-range-btn\" data-range=\"7d\">7d</button>\n            <button class=\"stats-range-btn\" data-range=\"30d\">30d</button>\n            <button class=\"stats-range-btn\" data-range=\"1y\">1y</button>\n          </div>\n        </div>\n        <div id=\"stats-history-container-area\" class=\"scroll-container\">\n          <div class=\"panel-empty\">\n            <span class=\"empty-icon\">\uD83D\uDCCA</span>\n            Choose a container and time range to view history.\n          </div>\n        </div>\n      </div>\n\n      <!-- Tab: Alert Configuration -->\n      <div id=\"stats-alerts\" class=\"panel-section\">\n        <div id=\"stats-alerts-container\" class=\"scroll-container\">\n          <div class=\"panel-empty\">\n            <span class=\"empty-icon\">\uD83D\uDD14</span>\n            Loading alert configurations...\n          </div>\n        </div>\n      </div>\n\n      <!-- Auto-refresh toggle (bottom bar) -->\n      <div class=\"panel-bottom-bar\">\n        <label class=\"checkbox-label\" style=\"font-size: 0.85rem;\">\n          <input type=\"checkbox\" id=\"stats-auto-refresh\" checked />\n          Auto-refresh every 5s\n        </label>\n        <button id=\"stats-refresh-btn\" class=\"btn-sm\">\uD83D\uDD04 Refresh Now</button>\n        <span id=\"stats-last-update\" class=\"text-auto-right\"></span>\n      </div>\n\n      <!-- Close Button -->\n      <div class=\"weather-modal-buttons modal-footer-bar\">\n        <button id=\"stats-cancel\">Close</button>\n      </div>\n    </div>\n  </div>`);\n\n  const modal = document.getElementById('stats-modal');\n  const openBtn = document.getElementById('container-stats-btn');\n  const cancelBtn = document.getElementById('stats-cancel');\n  const refreshBtn = document.getElementById('stats-refresh-btn');\n  const autoRefreshCheckbox = document.getElementById('stats-auto-refresh');\n  const container = document.getElementById('stats-container');\n  const aggregatedContainer = document.getElementById('stats-aggregated-container');\n  const alertsContainer = document.getElementById('stats-alerts-container');\n  const lastUpdateSpan = document.getElementById('stats-last-update');\n\n  let refreshInterval = null;\n  let cachedMonitoringData = null;\n\n  function formatBytes(bytes) {\n    if (bytes === 0 || !bytes) return '0 B';\n    const k = 1024;\n    const sizes = ['B', 'KB', 'MB', 'GB'];\n    const i = Math.floor(Math.log(bytes) / Math.log(k));\n    return parseFloat((bytes / Math.pow(k, i)).toFixed(1)) + ' ' + sizes[i];\n  }\n\n  function getCpuColor(percent) {\n    if (percent < 30) return '#2ecc71';\n    if (percent < 70) return '#f39c12';\n    return '#e74c3c';\n  }\n\n  function getMemColor(percent) {\n    if (percent < 50) return '#2ecc71';\n    if (percent < 80) return '#f39c12';\n    return '#e74c3c';\n  }\n\n  async function loadStats() {\n    try {\n      // Try new monitoring API first, fall back to old\n      let stats = null;\n      let isNewApi = false;\n      try {\n        const res = await fetch('/api/v1/monitoring/stats');\n        const data = await res.json();\n        if (data.success && data.stats) { stats = data.stats; isNewApi = true; cachedMonitoringData = data.stats; }\n      } catch (_) {}\n\n      if (!isNewApi) {\n        const response = await fetch('/api/v1/stats/containers');\n        const data = await response.json();\n        if (data.success && data.stats) {\n          // Convert array format to object format\n          stats = {};\n          for (const s of data.stats) {\n            stats[s.name] = { name: s.name, current: { cpu: s.cpu, memory: { percent: s.memory.percent, usage: s.memory.used, limit: s.memory.limit, usageMB: Math.round(s.memory.used / 1048576), limitMB: Math.round(s.memory.limit / 1048576) }, network: { rxBytes: s.network.rx, txBytes: s.network.tx, rxMB: (s.network.rx / 1048576).toFixed(1), txMB: (s.network.tx / 1048576).toFixed(1) }, disk: { readMB: 0, writeMB: 0 } }, status: s.status };\n          }\n          cachedMonitoringData = stats;\n        }\n      }\n\n      if (!stats || Object.keys(stats).length === 0) {\n        container.innerHTML = '<div style=\"text-align: center; padding: 40px; color: var(--muted);\">No running containers found</div>';\n        return;\n      }\n\n      let html = '<div style=\"display: flex; flex-direction: column; gap: 8px;\">';\n\n      for (const [id, info] of Object.entries(stats)) {\n        const cur = info.current || info;\n        const cpu = cur.cpu?.percent || 0;\n        const mem = cur.memory?.percent || 0;\n        const cpuColor = getCpuColor(cpu);\n        const memColor = getMemColor(mem);\n        const memUsed = cur.memory?.usage || cur.memory?.used || 0;\n        const memLimit = cur.memory?.limit || 0;\n        const netRx = cur.network?.rxBytes || cur.network?.rx || 0;\n        const netTx = cur.network?.txBytes || cur.network?.tx || 0;\n        const agg = info.aggregated;\n\n        html += `\n          <div style=\"padding: 12px; background: var(--card-base); border-radius: 8px; border: 1px solid var(--border);\">\n            <div style=\"display: flex; align-items: center; gap: 12px; margin-bottom: 10px;\">\n              <span style=\"font-weight: 600; flex: 1;\">${info.name || id}</span>\n              ${agg ? `<span style=\"font-size: 0.65rem; color: var(--muted); padding: 2px 6px; background: color-mix(in srgb, var(--accent) 10%, transparent); border-radius: 4px;\">avg ${agg.cpu?.avg?.toFixed(0) || 0}% cpu</span>` : ''}\n              <span style=\"font-size: 0.75rem; color: var(--muted); background: var(--base); padding: 2px 8px; border-radius: 4px;\">${info.status || 'running'}</span>\n            </div>\n            <div style=\"display: grid; grid-template-columns: repeat(3, 1fr); gap: 12px;\">\n              <div>\n                <div style=\"font-size: 0.7rem; color: var(--muted); margin-bottom: 4px;\">CPU</div>\n                <div style=\"display: flex; align-items: center; gap: 8px;\">\n                  <div style=\"flex: 1; height: 6px; background: var(--base); border-radius: 3px; overflow: hidden;\">\n                    <div style=\"height: 100%; width: ${Math.min(cpu, 100)}%; background: ${cpuColor}; border-radius: 3px; transition: width 0.3s;\"></div>\n                  </div>\n                  <span style=\"font-size: 0.8rem; font-weight: 500; color: ${cpuColor}; min-width: 45px; text-align: right;\">${cpu.toFixed(1)}%</span>\n                </div>\n              </div>\n              <div>\n                <div style=\"font-size: 0.7rem; color: var(--muted); margin-bottom: 4px;\">Memory</div>\n                <div style=\"display: flex; align-items: center; gap: 8px;\">\n                  <div style=\"flex: 1; height: 6px; background: var(--base); border-radius: 3px; overflow: hidden;\">\n                    <div style=\"height: 100%; width: ${Math.min(mem, 100)}%; background: ${memColor}; border-radius: 3px; transition: width 0.3s;\"></div>\n                  </div>\n                  <span style=\"font-size: 0.8rem; font-weight: 500; color: ${memColor}; min-width: 45px; text-align: right;\">${mem.toFixed(1)}%</span>\n                </div>\n                <div style=\"font-size: 0.65rem; color: var(--muted); margin-top: 2px;\">${formatBytes(memUsed)} / ${formatBytes(memLimit)}</div>\n              </div>\n              <div>\n                <div style=\"font-size: 0.7rem; color: var(--muted); margin-bottom: 4px;\">Network</div>\n                <div style=\"font-size: 0.8rem;\">\n                  <span style=\"color: #3498db;\">\u2193 ${formatBytes(netRx)}</span>\n                  <span style=\"color: var(--muted); margin: 0 4px;\">/</span>\n                  <span style=\"color: #e74c3c;\">\u2191 ${formatBytes(netTx)}</span>\n                </div>\n              </div>\n            </div>\n          </div>`;\n      }\n      html += '</div>';\n      container.innerHTML = html;\n      lastUpdateSpan.textContent = 'Updated: ' + new Date().toLocaleTimeString();\n    } catch (e) {\n      container.innerHTML = `<div style=\"text-align: center; padding: 40px; color: var(--bad-fg);\">\u274C Failed to load stats: ${escapeHtml(e.message)}</div>`;\n    }\n  }\n\n  // === 24h Aggregated Tab ===\n  async function loadAggregated() {\n    if (!aggregatedContainer) return;\n    const data = cachedMonitoringData;\n    if (!data || Object.keys(data).length === 0) {\n      aggregatedContainer.innerHTML = '<div class=\"panel-empty\"><span class=\"empty-icon\">\uD83D\uDCC8</span>No monitoring data available. Open the Live Stats tab first.</div>';\n      return;\n    }\n    let html = '<div style=\"display: flex; flex-direction: column; gap: 12px;\">';\n    for (const [id, info] of Object.entries(data)) {\n      const agg = info.aggregated;\n      if (!agg) continue;\n      html += `<div style=\"padding: 12px; background: var(--card-base); border-radius: 8px; border: 1px solid var(--border);\">\n        <div style=\"font-weight: 600; margin-bottom: 10px;\">${info.name || id}</div>\n        <div style=\"display: grid; grid-template-columns: repeat(4, 1fr); gap: 8px;\">\n          <div class=\"stat-mini-card\"><span class=\"stat-val\">${agg.cpu?.avg?.toFixed(1) || 0}%</span><span class=\"stat-lbl\">Avg CPU</span></div>\n          <div class=\"stat-mini-card\"><span class=\"stat-val\">${agg.cpu?.max?.toFixed(1) || 0}%</span><span class=\"stat-lbl\">Max CPU</span></div>\n          <div class=\"stat-mini-card\"><span class=\"stat-val\">${agg.memory?.avg?.toFixed(1) || 0}%</span><span class=\"stat-lbl\">Avg Mem</span></div>\n          <div class=\"stat-mini-card\"><span class=\"stat-val\">${agg.memory?.max?.toFixed(1) || 0}%</span><span class=\"stat-lbl\">Max Mem</span></div>\n        </div>\n        ${agg.dataPoints ? `<div style=\"font-size: 0.7rem; color: var(--muted); margin-top: 6px;\">${agg.dataPoints} data points over ${agg.timeRange || 24}h</div>` : ''}\n      </div>`;\n    }\n    html += '</div>';\n    aggregatedContainer.innerHTML = html;\n  }\n\n  // === Alerts Tab ===\n  async function loadAlerts() {\n    if (!alertsContainer) return;\n    alertsContainer.innerHTML = '<div class=\"panel-empty\"><span class=\"brand-spinner\"></span> Loading alerts...</div>';\n\n    const data = cachedMonitoringData;\n    if (!data || Object.keys(data).length === 0) {\n      alertsContainer.innerHTML = '<div class=\"panel-empty\"><span class=\"empty-icon\">\uD83D\uDD14</span>No containers found. Open the Live Stats tab first.</div>';\n      return;\n    }\n\n    // Check premium status for config section visibility\n    let isPremium = false;\n    try {\n      const resp = await fetch('/api/v1/license/feature/resource-alerts');\n      const ld = await resp.json();\n      isPremium = ld.available;\n    } catch (_) { isPremium = false; }\n\n    // Fetch alert history\n    let alertHistory = [];\n    try {\n      const hr = await fetch('/api/v1/monitoring/alerts?limit=50');\n      const hd = await hr.json();\n      if (hd.success) alertHistory = hd.history || [];\n    } catch (_) {}\n\n    // Fetch all alert configs\n    let allConfigs = {};\n    try {\n      const cr = await fetch('/api/v1/monitoring/alerts/config');\n      const cd = await cr.json();\n      if (cd.success) allConfigs = cd.configs || {};\n    } catch (_) {}\n\n    const containers = Object.entries(data);\n    const containerRows = containers.map(([id, info]) => {\n      const cfg = allConfigs[id] || { cpuThreshold: 80, memoryThreshold: 90, diskIOThreshold: 50, autoRestart: false, enabled: false };\n      return `\n        <tr data-container=\"${id}\">\n          <td style=\"font-weight: 600; padding: 8px;\">${info.name || id}</td>\n          <td style=\"padding: 4px 8px;\"><input type=\"number\" class=\"alert-cpu\" value=\"${cfg.cpuThreshold ?? 80}\" min=\"0\" max=\"100\" style=\"width: 60px; font-size: 0.8rem; padding: 2px 4px;\" ${isPremium ? '' : 'disabled'} /></td>\n          <td style=\"padding: 4px 8px;\"><input type=\"number\" class=\"alert-mem\" value=\"${cfg.memoryThreshold ?? 90}\" min=\"0\" max=\"100\" style=\"width: 60px; font-size: 0.8rem; padding: 2px 4px;\" ${isPremium ? '' : 'disabled'} /></td>\n          <td style=\"padding: 4px 8px;\"><input type=\"number\" class=\"alert-disk\" value=\"${cfg.diskIOThreshold ?? 50}\" min=\"0\" max=\"1000\" style=\"width: 70px; font-size: 0.8rem; padding: 2px 4px;\" ${isPremium ? '' : 'disabled'} /></td>\n          <td style=\"padding: 4px 8px;\"><input type=\"checkbox\" class=\"alert-autorestart\" ${cfg.autoRestart ? 'checked' : ''} ${isPremium ? '' : 'disabled'} /></td>\n          <td style=\"padding: 4px 8px;\">\n            <button class=\"alert-test-btn btn-xs\" data-container=\"${id}\" data-name=\"${info.name || id}\" style=\"padding: 2px 8px; font-size: 0.75rem; background: var(--card-base); border: 1px solid var(--border); border-radius: 4px; cursor: pointer;\">Test</button>\n          </td>\n        </tr>\n      `;\n    }).join('');\n\n    const historyRows = alertHistory.map(entry => {\n      const time = new Date(entry.timestamp).toLocaleString();\n      const notifiedMark = entry.notified ? '\u2713' : '\u2014';\n      return `\n        <tr>\n          <td style=\"padding: 6px 8px; font-size: 0.8rem; color: var(--muted);\">${time}</td>\n          <td style=\"padding: 6px 8px; font-weight: 500;\">${entry.containerName || entry.containerId}</td>\n          <td style=\"padding: 6px 8px; text-transform: capitalize;\">${entry.metric || entry.type}</td>\n          <td style=\"padding: 6px 8px;\">${typeof entry.value === 'number' ? entry.value.toFixed(1) : entry.value}${entry.metric === 'disk' ? ' MB/s' : '%'}</td>\n          <td style=\"padding: 6px 8px; text-align: center;\">${notifiedMark}</td>\n          <td style=\"padding: 6px 8px; font-size: 0.75rem; color: ${entry.autoRestartTriggered ? '#f39c12' : 'var(--muted)'};\">${entry.autoRestartTriggered ? '\u21BB' : ''}</td>\n        </tr>\n      `;\n    }).join('');\n\n    const configSection = isPremium ? `\n      <div style=\"margin-bottom: 20px;\">\n        <div style=\"display: flex; align-items: center; justify-content: space-between; margin-bottom: 10px;\">\n          <h4 style=\"margin: 0; font-size: 0.9rem;\">\u2699\uFE0F Alert Configuration</h4>\n          <a href=\"#\" id=\"go-to-notifications\" style=\"font-size: 0.8rem; color: var(--accent); text-decoration: none;\">Configure notifications \u2192</a>\n        </div>\n        <div style=\"overflow-x: auto;\">\n          <table style=\"width: 100%; border-collapse: collapse; font-size: 0.85rem;\">\n            <thead>\n              <tr style=\"border-bottom: 1px solid var(--border);\">\n                <th style=\"text-align: left; padding: 6px 8px; color: var(--muted);\">Container</th>\n                <th style=\"text-align: left; padding: 6px 8px; color: var(--muted);\">CPU %</th>\n                <th style=\"text-align: left; padding: 6px 8px; color: var(--muted);\">Mem %</th>\n                <th style=\"text-align: left; padding: 6px 8px; color: var(--muted);\">Disk I/O MB/s</th>\n                <th style=\"text-align: center; padding: 6px 8px; color: var(--muted);\">Auto-Restart</th>\n                <th style=\"padding: 6px 8px;\"></th>\n              </tr>\n            </thead>\n            <tbody>${containerRows}</tbody>\n          </table>\n        </div>\n        <div style=\"margin-top: 12px; display: flex; justify-content: flex-end;\">\n          <button id=\"save-all-alerts\" style=\"padding: 6px 16px; font-size: 0.85rem; background: var(--accent); color: var(--base); border: none; border-radius: 4px; cursor: pointer; font-weight: 600;\">Save All</button>\n        </div>\n      </div>\n    ` : `\n      <div style=\"margin-bottom: 20px; padding: 12px; background: rgba(241,196,15,0.1); border: 1px solid rgba(241,196,15,0.3); border-radius: 8px; text-align: center;\">\n        <span style=\"color: #f1c40f; font-weight: 600; font-size: 0.85rem;\">\u2B50 Premium Feature</span>\n        <p style=\"margin: 6px 0 0; font-size: 0.75rem; color: var(--muted);\">Upgrade to configure resource alert thresholds per container.</p>\n        <button id=\"upgrade-for-alerts\" style=\"margin-top: 8px; padding: 4px 12px; font-size: 0.75rem; background: #f1c40f; color: #000; border: none; border-radius: 4px; cursor: pointer; font-weight: 600;\">Upgrade Now</button>\n      </div>\n    `;\n\n    alertsContainer.innerHTML = `\n      ${configSection}\n      <div>\n        <h4 style=\"margin: 0 0 10px; font-size: 0.9rem;\">\uD83D\uDCCB Recent Alerts</h4>\n        ${historyRows ? `\n          <div style=\"overflow-x: auto;\">\n            <table style=\"width: 100%; border-collapse: collapse; font-size: 0.8rem;\">\n              <thead>\n                <tr style=\"border-bottom: 1px solid var(--border);\">\n                  <th style=\"text-align: left; padding: 6px 8px; color: var(--muted);\">Time</th>\n                  <th style=\"text-align: left; padding: 6px 8px; color: var(--muted);\">Container</th>\n                  <th style=\"text-align: left; padding: 6px 8px; color: var(--muted);\">Metric</th>\n                  <th style=\"text-align: left; padding: 6px 8px; color: var(--muted);\">Value</th>\n                  <th style=\"text-align: center; padding: 6px 8px; color: var(--muted);\">\u2713?</th>\n                  <th style=\"padding: 6px 8px;\"></th>\n                </tr>\n              </thead>\n              <tbody>${historyRows}</tbody>\n            </table>\n          </div>\n        ` : '<div style=\"color: var(--muted); text-align: center; padding: 20px;\">No alerts recorded yet.</div>'}\n      </div>\n    `;\n\n    // Wire up save-all button\n    document.getElementById('save-all-alerts')?.addEventListener('click', async () => {\n      const configs = {};\n      document.querySelectorAll('#stats-alerts-container tr[data-container]').forEach(row => {\n        const cId = row.dataset.container;\n        configs[cId] = {\n          cpuThreshold: parseInt(row.querySelector('.alert-cpu')?.value) || 80,\n          memoryThreshold: parseInt(row.querySelector('.alert-mem')?.value) || 90,\n          diskIOThreshold: parseInt(row.querySelector('.alert-disk')?.value) || 50,\n          autoRestart: !!row.querySelector('.alert-autorestart')?.checked,\n          enabled: true\n        };\n      });\n      try {\n        const res = await secureFetch('/api/v1/monitoring/alerts/config', {\n          method: 'POST',\n          headers: { 'Content-Type': 'application/json' },\n          body: JSON.stringify({ configs })\n        });\n        const d = await res.json();\n        const btn = document.getElementById('save-all-alerts');\n        btn.textContent = d.success ? '\u2705 Saved' : '\u274C Failed';\n        setTimeout(() => { btn.textContent = 'Save All'; }, 2000);\n      } catch (e) {\n        const btn = document.getElementById('save-all-alerts');\n        btn.textContent = '\u274C Error';\n        setTimeout(() => { btn.textContent = 'Save All'; }, 2000);\n      }\n    });\n\n    // Wire up notification settings link\n    document.getElementById('go-to-notifications')?.addEventListener('click', (e) => {\n      e.preventDefault();\n      modal.classList.remove('show');\n      stopAutoRefresh();\n      document.getElementById('manage-notifications')?.click();\n    });\n\n    // Wire up test buttons\n    document.querySelectorAll('.alert-test-btn').forEach(btn => {\n      btn.addEventListener('click', async () => {\n        const orig = btn.textContent;\n        btn.textContent = '...';\n        try {\n          await secureFetch(`/api/v1/monitoring/alerts/${btn.dataset.container}/test`, { method: 'POST' });\n          btn.textContent = '\u2705';\n          showNotification('Test alert sent for ' + btn.dataset.name, 'success', 3000);\n        } catch (e) {\n          btn.textContent = '\u274C';\n        }\n        setTimeout(() => { btn.textContent = orig; }, 2000);\n      });\n    });\n\n    // Wire up upgrade button\n    document.getElementById('upgrade-for-alerts')?.addEventListener('click', () => {\n      modal.classList.remove('show');\n      stopAutoRefresh();\n      if (typeof openLicenseModal === 'function') openLicenseModal();\n    });\n  }\n\n  function startAutoRefresh() {\n    if (refreshInterval) clearInterval(refreshInterval);\n    if (autoRefreshCheckbox?.checked) {\n      refreshInterval = setInterval(loadStats, DC.POLL.STATS);\n    }\n  }\n\n  function stopAutoRefresh() {\n    if (refreshInterval) {\n      clearInterval(refreshInterval);\n      refreshInterval = null;\n    }\n  }\n\n  // Open modal\n  openBtn?.addEventListener('click', () => {\n    modal.classList.add('show');\n    loadStats();\n    startAutoRefresh();\n  });\n\n  // Close modal\n  cancelBtn?.addEventListener('click', () => {\n    modal.classList.remove('show');\n    stopAutoRefresh();\n  });\n\n  modal?.addEventListener('click', (e) => {\n    if (e.target === modal) {\n      modal.classList.remove('show');\n      stopAutoRefresh();\n    }\n  });\n\n  refreshBtn?.addEventListener('click', loadStats);\n\n  autoRefreshCheckbox?.addEventListener('change', () => {\n    if (autoRefreshCheckbox.checked) startAutoRefresh();\n    else stopAutoRefresh();\n  });\n\n  // Lazy-load tabs\n  document.querySelector('[data-panel=\"stats-aggregated\"]')?.addEventListener('click', loadAggregated);\n  document.querySelector('[data-panel=\"stats-alerts\"]')?.addEventListener('click', loadAlerts);\n\n  // === History Tab ===\n  const historyContainerSelect = document.getElementById('stats-history-container');\n  const historyArea = document.getElementById('stats-history-container-area');\n  const rangeButtons = document.querySelectorAll('.stats-range-btn');\n\n  let currentRange = '1h';\n\n  function rangeToMs(range) {\n    switch (range) {\n      case '1h':  return 60 * 60 * 1000;\n      case '24h': return 24 * 60 * 60 * 1000;\n      case '7d':  return 7 * 24 * 60 * 60 * 1000;\n      case '30d': return 30 * 24 * 60 * 60 * 1000;\n      case '1y':  return 365 * 24 * 60 * 60 * 1000;\n      default:    return 60 * 60 * 1000;\n    }\n  }\n\n  function tierLabel(tier) {\n    if (tier === 'raw') return 'live (10s samples)';\n    if (tier === 'hourly') return 'hourly average';\n    if (tier === 'daily') return 'daily average';\n    return tier;\n  }\n\n  // Simple SVG sparkline \u2014 no external lib\n  function renderSparkline(samples, accessor, color, label, unit) {\n    if (!samples || samples.length === 0) {\n      return `<div style=\"text-align: center; color: var(--muted); padding: 20px;\">No data for ${escapeHtml(label)}</div>`;\n    }\n    const values = samples.map(accessor).filter(v => v != null);\n    if (values.length === 0) {\n      return `<div style=\"text-align: center; color: var(--muted); padding: 20px;\">No data for ${escapeHtml(label)}</div>`;\n    }\n    const max = Math.max(...values, 1);\n    const min = Math.min(...values, 0);\n    const range = max - min || 1;\n    const w = 600, h = 80, pad = 4;\n    const stepX = (w - pad * 2) / Math.max(values.length - 1, 1);\n    const points = values.map((v, i) => {\n      const x = pad + i * stepX;\n      const y = h - pad - ((v - min) / range) * (h - pad * 2);\n      return `${x.toFixed(1)},${y.toFixed(1)}`;\n    }).join(' ');\n    const last = values[values.length - 1];\n    const avg = values.reduce((a, b) => a + b, 0) / values.length;\n    return `\n      <div style=\"margin-bottom: 14px;\">\n        <div style=\"display: flex; align-items: baseline; gap: 12px; margin-bottom: 4px;\">\n          <span style=\"font-weight: 600; font-size: 0.9rem;\">${escapeHtml(label)}</span>\n          <span style=\"font-size: 0.75rem; color: var(--muted);\">last ${last.toFixed(1)}${unit} \u00B7 avg ${avg.toFixed(1)}${unit} \u00B7 max ${max.toFixed(1)}${unit}</span>\n        </div>\n        <svg viewBox=\"0 0 ${w} ${h}\" preserveAspectRatio=\"none\" style=\"width: 100%; height: ${h}px; background: var(--base); border-radius: 4px;\">\n          <polyline fill=\"none\" stroke=\"${color}\" stroke-width=\"1.5\" points=\"${points}\" />\n        </svg>\n      </div>\n    `;\n  }\n\n  function populateHistoryContainerSelect() {\n    if (!historyContainerSelect) return;\n    const data = cachedMonitoringData || {};\n    const previous = historyContainerSelect.value;\n    const entries = Object.entries(data);\n    if (entries.length === 0) {\n      historyContainerSelect.innerHTML = '<option value=\"\">No containers</option>';\n      return;\n    }\n    historyContainerSelect.innerHTML = entries\n      .map(([id, info]) => `<option value=\"${escapeHtml(id)}\">${escapeHtml(info.name || id)}</option>`)\n      .join('');\n    if (previous && data[previous]) historyContainerSelect.value = previous;\n  }\n\n  async function loadHistory() {\n    if (!historyArea || !historyContainerSelect) return;\n    const containerId = historyContainerSelect.value;\n    if (!containerId) {\n      historyArea.innerHTML = '<div class=\"panel-empty\"><span class=\"empty-icon\">\uD83D\uDCCA</span>No container selected.</div>';\n      return;\n    }\n    const endTime = Date.now();\n    const startTime = endTime - rangeToMs(currentRange);\n    historyArea.innerHTML = '<div class=\"panel-empty\"><span class=\"brand-spinner\"></span> Loading history...</div>';\n\n    try {\n      const res = await fetch(`/api/v1/monitoring/history/${encodeURIComponent(containerId)}?startTime=${startTime}&endTime=${endTime}`);\n      const data = await res.json();\n      if (!data.success) throw new Error(data.error || 'Failed to load history');\n\n      const samples = data.samples || [];\n      const tier = data.tier || 'raw';\n\n      if (samples.length === 0) {\n        historyArea.innerHTML = `<div class=\"panel-empty\"><span class=\"empty-icon\">\uD83D\uDCCA</span>No data for the last ${currentRange}. Tier: ${tierLabel(tier)}.</div>`;\n        return;\n      }\n\n      // Different shape between raw vs rolled-up samples\n      const isRaw = tier === 'raw';\n      const cpuAccessor = isRaw ? (s) => s.cpu?.percent : (s) => s.cpu?.avg;\n      const memAccessor = isRaw ? (s) => s.memory?.percent : (s) => s.memory?.avgPercent;\n      const netRxAccessor = isRaw ? (s) => (s.network?.rxMB || 0) : (s) => (s.network?.rxMB || 0);\n      const netTxAccessor = isRaw ? (s) => (s.network?.txMB || 0) : (s) => (s.network?.txMB || 0);\n\n      let html = `\n        <div style=\"font-size: 0.75rem; color: var(--muted); margin-bottom: 8px;\">\n          ${samples.length} samples \u00B7 ${escapeHtml(tierLabel(tier))} \u00B7 ${new Date(startTime).toLocaleString()} \u2192 ${new Date(endTime).toLocaleString()}\n        </div>\n      `;\n      html += renderSparkline(samples, cpuAccessor, '#2ecc71', 'CPU', '%');\n      html += renderSparkline(samples, memAccessor, '#3498db', 'Memory', '%');\n      html += renderSparkline(samples, netRxAccessor, '#9b59b6', 'Network RX', ' MB');\n      html += renderSparkline(samples, netTxAccessor, '#e67e22', 'Network TX', ' MB');\n\n      historyArea.innerHTML = html;\n    } catch (e) {\n      historyArea.innerHTML = `<div class=\"panel-empty\"><span class=\"empty-icon\">\u26A0\uFE0F</span>Failed to load history: ${escapeHtml(e.message)}</div>`;\n    }\n  }\n\n  rangeButtons.forEach(btn => {\n    btn.addEventListener('click', () => {\n      rangeButtons.forEach(b => b.classList.remove('active'));\n      btn.classList.add('active');\n      currentRange = btn.dataset.range;\n      loadHistory();\n    });\n  });\n\n  historyContainerSelect?.addEventListener('change', loadHistory);\n\n  document.querySelector('[data-panel=\"stats-history\"]')?.addEventListener('click', () => {\n    populateHistoryContainerSelect();\n    loadHistory();\n  });\n})();\n;\n// ========== HEALTH CHECK DASHBOARD ==========\n(function() {\n  // Inject modal HTML\n  injectModal('health-modal', `<div id=\"health-modal\" class=\"weather-modal\">\n    <div class=\"weather-modal-content\" style=\"min-width: 800px; max-width: 1000px;\">\n      <h3>\uD83C\uDFE5 Health Check Dashboard</h3>\n      <p class=\"modal-subtitle\">\n        Service uptime tracking, SLA monitoring, and incident management.\n      </p>\n\n      <div class=\"panel-tabs\">\n        <button class=\"panel-tab active\" data-panel=\"health-status\">Status</button>\n        <button class=\"panel-tab\" data-panel=\"health-incidents\">Incidents</button>\n        <button class=\"panel-tab\" data-panel=\"health-config\">Configure</button>\n      </div>\n\n      <!-- Tab: Status -->\n      <div id=\"health-status\" class=\"panel-section active\">\n        <div id=\"health-status-container\" class=\"scroll-container\">\n          <div class=\"panel-empty\"><span class=\"brand-spinner\"></span> Loading health status...</div>\n        </div>\n      </div>\n\n      <!-- Tab: Incidents -->\n      <div id=\"health-incidents\" class=\"panel-section\">\n        <div id=\"health-incidents-container\" class=\"scroll-container\">\n          <div class=\"panel-empty\"><span class=\"empty-icon\">\uD83D\uDEA8</span> Loading incidents...</div>\n        </div>\n      </div>\n\n      <!-- Tab: Configure -->\n      <div id=\"health-config\" class=\"panel-section\">\n        <div id=\"health-config-container\" class=\"scroll-container\">\n          <div class=\"panel-empty\"><span class=\"empty-icon\">\u2699\uFE0F</span> Loading configuration...</div>\n        </div>\n\n        <!-- Global Settings: retention, polling intervals, max entries, disk-usage threshold -->\n        <div id=\"health-global-settings\" style=\"margin-top: 16px; padding: 16px; border: 1px solid var(--border); border-radius: var(--radius); background: var(--card-base);\">\n          <h4 style=\"margin: 0 0 4px;\">\uD83C\uDF0D Global Settings</h4>\n          <p class=\"text-muted-sm\" style=\"margin: 0 0 12px;\">Applies to all health checks. Settings are stored locally in this browser.</p>\n          <div style=\"display: grid; grid-template-columns: 1fr 1fr; gap: 12px;\">\n            <div>\n              <label class=\"text-muted-sm\">Health Check Polling Interval (seconds)</label>\n              <input type=\"number\" id=\"health-setting-interval\" value=\"60\" min=\"5\" max=\"3600\" class=\"form-input\" />\n              <div style=\"font-size: 0.72rem; color: var(--muted); margin-top: 2px;\">How often each service's health endpoint is checked.</div>\n            </div>\n            <div>\n              <label class=\"text-muted-sm\">Stats Polling Interval (seconds)</label>\n              <input type=\"number\" id=\"health-setting-stats-interval\" value=\"30\" min=\"5\" max=\"3600\" class=\"form-input\" />\n              <div style=\"font-size: 0.72rem; color: var(--muted); margin-top: 2px;\">How often container statistics (CPU/memory) are sampled.</div>\n            </div>\n            <div>\n              <label class=\"text-muted-sm\">Max Entries Per Service</label>\n              <input type=\"number\" id=\"health-setting-max-entries\" value=\"500\" min=\"10\" max=\"100000\" class=\"form-input\" />\n              <div style=\"font-size: 0.72rem; color: var(--muted); margin-top: 2px;\">Cap on stored history records per service.</div>\n            </div>\n            <div>\n              <label class=\"text-muted-sm\">Data Retention (days)</label>\n              <input type=\"number\" id=\"health-setting-retention\" value=\"30\" min=\"1\" max=\"3650\" class=\"form-input\" />\n              <div style=\"font-size: 0.72rem; color: var(--muted); margin-top: 2px;\">Health history older than this is pruned.</div>\n            </div>\n            <div>\n              <label class=\"text-muted-sm\">Disk-Usage Warning (%)</label>\n              <input type=\"number\" id=\"health-setting-disk-threshold\" value=\"80\" min=\"50\" max=\"99\" class=\"form-input\" />\n              <div style=\"font-size: 0.72rem; color: var(--muted); margin-top: 2px;\">Warn when disk usage exceeds this level.</div>\n            </div>\n          </div>\n          <div style=\"margin-top: 12px; display: flex; gap: 8px; align-items: center;\">\n            <button id=\"health-global-save\" class=\"btn-accent-solid\">Save Global Settings</button>\n            <button id=\"health-global-reset\" class=\"btn-sm\">Reset to Defaults</button>\n            <span id=\"health-global-status\" style=\"font-size: 0.8rem; color: var(--muted);\"></span>\n          </div>\n        </div>\n\n        <!-- Add/Edit Health Check Form -->\n        <div id=\"health-config-form\" style=\"display: none; margin-top: 16px; padding: 16px; border: 1px solid var(--border); border-radius: var(--radius); background: var(--card-base);\">\n          <h4 id=\"health-form-title\" style=\"margin: 0 0 12px;\">Add Health Check</h4>\n          <div style=\"display: grid; grid-template-columns: 1fr 1fr; gap: 12px;\">\n            <div>\n              <label class=\"text-muted-sm\">Service ID</label>\n              <input type=\"text\" id=\"health-form-id\" placeholder=\"e.g. plex\" class=\"form-input\" />\n            </div>\n            <div>\n              <label class=\"text-muted-sm\">Display Name</label>\n              <input type=\"text\" id=\"health-form-name\" placeholder=\"e.g. Plex Media Server\" class=\"form-input\" />\n            </div>\n            <div style=\"grid-column: span 2;\">\n              <label class=\"text-muted-sm\">URL</label>\n              <input type=\"text\" id=\"health-form-url\" placeholder=\"https://plex.home\" class=\"form-input\" />\n            </div>\n            <div>\n              <label class=\"text-muted-sm\">Timeout (ms)</label>\n              <input type=\"number\" id=\"health-form-timeout\" value=\"10000\" class=\"form-input\" />\n            </div>\n            <div>\n              <label class=\"text-muted-sm\">Expected Status Codes</label>\n              <input type=\"text\" id=\"health-form-codes\" value=\"200\" placeholder=\"200, 301, 302\" class=\"form-input\" />\n            </div>\n            <div>\n              <label class=\"text-muted-sm\">SLA Target (%)</label>\n              <input type=\"number\" id=\"health-form-sla\" value=\"99.9\" step=\"0.1\" class=\"form-input\" />\n            </div>\n            <div>\n              <label class=\"text-muted-sm\">Slow Response Threshold (ms)</label>\n              <input type=\"number\" id=\"health-form-slow\" value=\"5000\" class=\"form-input\" />\n            </div>\n          </div>\n          <div style=\"margin-top: 12px; display: flex; gap: 8px; justify-content: flex-end;\">\n            <button id=\"health-form-cancel\">Cancel</button>\n            <button id=\"health-form-save\" class=\"btn-accent-solid\">Save</button>\n          </div>\n        </div>\n\n        <div style=\"margin-top: 12px;\">\n          <button id=\"health-add-btn\" class=\"btn-accent-solid\">+ Add Health Check</button>\n        </div>\n      </div>\n\n      <div class=\"panel-bottom-bar\">\n        <button id=\"health-refresh-btn\" class=\"btn-sm\">\uD83D\uDD04 Refresh</button>\n        <span id=\"health-last-update\" class=\"text-auto-right\"></span>\n      </div>\n\n      <div class=\"weather-modal-buttons modal-footer-bar\">\n        <button id=\"health-cancel\">Close</button>\n      </div>\n    </div>\n  </div>`);\n\n  const modal = document.getElementById('health-modal');\n  const openBtn = document.getElementById('health-check-btn');\n  const cancelBtn = document.getElementById('health-cancel');\n  const refreshBtn = document.getElementById('health-refresh-btn');\n  const statusContainer = document.getElementById('health-status-container');\n  const incidentsContainer = document.getElementById('health-incidents-container');\n  const configContainer = document.getElementById('health-config-container');\n  const lastUpdateSpan = document.getElementById('health-last-update');\n  const addBtn = document.getElementById('health-add-btn');\n  const formEl = document.getElementById('health-config-form');\n  const formTitle = document.getElementById('health-form-title');\n  const formCancel = document.getElementById('health-form-cancel');\n  const formSave = document.getElementById('health-form-save');\n\n  // ---- Global health settings (retention, polling intervals, max entries, disk threshold) ----\n  const HEALTH_SETTINGS_KEY = 'dashcaddy-health-settings';\n  const HEALTH_DEFAULTS = { retentionDays: 30, pollingInterval: 60, statsPollingInterval: 30, maxEntriesPerService: 500, diskUsageThreshold: 80 };\n  const globalSaveBtn = document.getElementById('health-global-save');\n  const globalResetBtn = document.getElementById('health-global-reset');\n  const globalStatusSpan = document.getElementById('health-global-status');\n  const retentionInput = document.getElementById('health-setting-retention');\n  const intervalInput = document.getElementById('health-setting-interval');\n  const statsIntervalInput = document.getElementById('health-setting-stats-interval');\n  const maxEntriesInput = document.getElementById('health-setting-max-entries');\n  const diskThresholdInput = document.getElementById('health-setting-disk-threshold');\n\n  function loadHealthSettings() {\n    try {\n      const raw = safeGet(HEALTH_SETTINGS_KEY);\n      const saved = raw ? JSON.parse(raw) : {};\n      return Object.assign({}, HEALTH_DEFAULTS, saved);\n    } catch (_) {\n      return Object.assign({}, HEALTH_DEFAULTS);\n    }\n  }\n\n  function applyHealthSettingsToUI() {\n    const s = loadHealthSettings();\n    if (retentionInput) retentionInput.value = s.retentionDays;\n    if (intervalInput) intervalInput.value = s.pollingInterval;\n    if (statsIntervalInput) statsIntervalInput.value = s.statsPollingInterval;\n    if (maxEntriesInput) maxEntriesInput.value = s.maxEntriesPerService;\n    if (diskThresholdInput) diskThresholdInput.value = s.diskUsageThreshold;\n  }\n\n  function saveHealthSettings() {\n    const settings = {\n      retentionDays: Math.max(1, Math.min(3650, parseInt(retentionInput?.value) || HEALTH_DEFAULTS.retentionDays)),\n      pollingInterval: Math.max(5, Math.min(3600, parseInt(intervalInput?.value) || HEALTH_DEFAULTS.pollingInterval)),\n      statsPollingInterval: Math.max(5, Math.min(3600, parseInt(statsIntervalInput?.value) || HEALTH_DEFAULTS.statsPollingInterval)),\n      maxEntriesPerService: Math.max(10, Math.min(100000, parseInt(maxEntriesInput?.value) || HEALTH_DEFAULTS.maxEntriesPerService)),\n      diskUsageThreshold: Math.max(50, Math.min(99, parseInt(diskThresholdInput?.value) || HEALTH_DEFAULTS.diskUsageThreshold))\n    };\n    try {\n      safeSet(HEALTH_SETTINGS_KEY, JSON.stringify(settings));\n      applyHealthSettingsToUI();\n      if (globalStatusSpan) {\n        globalStatusSpan.textContent = 'Saved \u2713';\n        globalStatusSpan.style.color = 'var(--ok-fg)';\n        setTimeout(() => { if (globalStatusSpan) globalStatusSpan.textContent = ''; }, 2500);\n      }\n      if (typeof showNotification === 'function') showNotification('Global health settings saved', 'success');\n    } catch (e) {\n      if (globalStatusSpan) { globalStatusSpan.textContent = 'Save failed'; globalStatusSpan.style.color = 'var(--bad-fg)'; }\n      if (typeof showNotification === 'function') showNotification('Failed to save settings: ' + e.message, 'error');\n    }\n  }\n\n  function resetHealthSettings() {\n    try {\n      safeSet(HEALTH_SETTINGS_KEY, JSON.stringify(HEALTH_DEFAULTS));\n    } catch (_) { /* ignore */ }\n    applyHealthSettingsToUI();\n    if (globalStatusSpan) {\n      globalStatusSpan.textContent = 'Reset to defaults \u2713';\n      globalStatusSpan.style.color = 'var(--ok-fg)';\n      setTimeout(() => { if (globalStatusSpan) globalStatusSpan.textContent = ''; }, 2500);\n    }\n  }\n\n  applyHealthSettingsToUI();\n  globalSaveBtn?.addEventListener('click', saveHealthSettings);\n  globalResetBtn?.addEventListener('click', resetHealthSettings);\n  // ---- End global health settings ----\n\n  let editingId = null;\n\n  function uptimeColor(pct) {\n    if (pct >= 99.9) return 'var(--ok-fg)';\n    if (pct >= 95) return '#f39c12';\n    return 'var(--bad-fg)';\n  }\n\n  function severityBadge(sev) {\n    const colors = { critical: 'var(--bad-fg)', high: '#ff6b6b', medium: '#f39c12', low: 'var(--muted)' };\n    return `<span style=\"padding: 2px 8px; border-radius: 4px; font-size: 0.75rem; background: ${colors[sev] || 'var(--muted)'}20; color: ${colors[sev] || 'var(--muted)'};\">${sev}</span>`;\n  }\n\n  async function loadStatus() {\n    try {\n      const res = await fetch('/api/v1/health-checks/status');\n      const data = await res.json();\n      if (!data.success || !data.status || Object.keys(data.status).length === 0) {\n        statusContainer.innerHTML = '<div class=\"panel-empty\"><span class=\"empty-icon\">\uD83C\uDFE5</span>No health checks configured. Go to the Configure tab to add services.</div>';\n        return;\n      }\n      const services = Object.values(data.status);\n      let html = '<table style=\"width: 100%; border-collapse: collapse; font-size: 0.85rem;\">';\n      html += '<tr style=\"border-bottom: 1px solid var(--border); color: var(--muted); text-align: left;\">';\n      html += '<th style=\"padding: 8px;\">Service</th><th style=\"padding: 8px;\">Status</th>';\n      html += '<th style=\"padding: 8px;\">Uptime 24h</th><th style=\"padding: 8px;\">Uptime 7d</th>';\n      html += '<th style=\"padding: 8px;\">Avg Response</th><th style=\"padding: 8px;\">Last Check</th></tr>';\n      for (const s of services) {\n        const isUp = s.status === 'up';\n        const dotColor = isUp ? 'var(--dot-ok)' : 'var(--dot-bad)';\n        const u24 = s.uptime?.['24h'] ?? '-';\n        const u7d = s.uptime?.['7d'] ?? '-';\n        const avgRt = s.avgResponseTime != null ? Math.round(s.avgResponseTime) + 'ms' : '-';\n        const lastCheck = s.timestamp ? timeAgo(s.timestamp) : '-';\n        html += `<tr style=\"border-bottom: 1px solid var(--border); cursor: pointer;\" data-health-id=\"${escapeHtml(s.serviceId)}\">`;\n        html += `<td style=\"padding: 8px; font-weight: 500;\">${escapeHtml(s.name || s.serviceId)}</td>`;\n        html += `<td style=\"padding: 8px;\"><span style=\"display: inline-block; width: 8px; height: 8px; border-radius: 50%; background: ${dotColor}; margin-right: 6px;\"></span>${isUp ? 'Up' : 'Down'}</td>`;\n        html += `<td style=\"padding: 8px; color: ${typeof u24 === 'number' ? uptimeColor(u24) : 'var(--muted)'};\">${typeof u24 === 'number' ? u24.toFixed(1) + '%' : u24}</td>`;\n        html += `<td style=\"padding: 8px; color: ${typeof u7d === 'number' ? uptimeColor(u7d) : 'var(--muted)'};\">${typeof u7d === 'number' ? u7d.toFixed(1) + '%' : u7d}</td>`;\n        html += `<td style=\"padding: 8px;\">${avgRt}</td>`;\n        html += `<td style=\"padding: 8px; color: var(--muted);\">${lastCheck}</td>`;\n        html += '</tr>';\n        html += `<tr id=\"health-detail-${escapeHtml(s.serviceId)}\" style=\"display: none;\"><td colspan=\"6\" style=\"padding: 12px; background: var(--bg); border-bottom: 1px solid var(--border);\"><div class=\"panel-empty\"><span class=\"brand-spinner\"></span> Loading details...</div></td></tr>`;\n      }\n      html += '</table>';\n      statusContainer.innerHTML = html;\n      lastUpdateSpan.textContent = 'Updated ' + new Date().toLocaleTimeString();\n\n      // Row click to expand details\n      statusContainer.querySelectorAll('tr[data-health-id]').forEach(row => {\n        row.addEventListener('click', async () => {\n          const id = row.dataset.healthId;\n          const detailRow = document.getElementById('health-detail-' + id);\n          if (!detailRow) return;\n          if (detailRow.style.display !== 'none') {\n            detailRow.style.display = 'none';\n            return;\n          }\n          detailRow.style.display = '';\n          try {\n            const r = await fetch(`/api/v1/health-checks/${id}/stats?hours=24`);\n            const d = await r.json();\n            if (d.success && d.stats) {\n              const st = d.stats;\n              const rt = st.responseTime || {};\n              detailRow.querySelector('td').innerHTML = `\n                <div style=\"display: grid; grid-template-columns: repeat(4, 1fr); gap: 12px; font-size: 0.82rem;\">\n                  <div><span style=\"color: var(--muted);\">Total Checks</span><br><strong>${st.totalChecks || 0}</strong></div>\n                  <div><span style=\"color: var(--muted);\">Uptime</span><br><strong style=\"color: ${uptimeColor(st.uptime || 0)};\">${(st.uptime || 0).toFixed(2)}%</strong></div>\n                  <div><span style=\"color: var(--muted);\">Avg Response</span><br><strong>${Math.round(rt.avg || 0)}ms</strong></div>\n                  <div><span style=\"color: var(--muted);\">P95 / P99</span><br><strong>${Math.round(rt.p95 || 0)}ms / ${Math.round(rt.p99 || 0)}ms</strong></div>\n                  <div><span style=\"color: var(--muted);\">Min Response</span><br><strong>${Math.round(rt.min || 0)}ms</strong></div>\n                  <div><span style=\"color: var(--muted);\">Max Response</span><br><strong>${Math.round(rt.max || 0)}ms</strong></div>\n                  <div><span style=\"color: var(--muted);\">Up Checks</span><br><strong style=\"color: var(--ok-fg);\">${st.upChecks || 0}</strong></div>\n                  <div><span style=\"color: var(--muted);\">Down Checks</span><br><strong style=\"color: var(--bad-fg);\">${st.downChecks || 0}</strong></div>\n                </div>`;\n            } else {\n              detailRow.querySelector('td').innerHTML = '<div class=\"panel-empty\">No detailed stats available for this period.</div>';\n            }\n          } catch (e) {\n            detailRow.querySelector('td').innerHTML = `<div class=\"panel-empty\" style=\"color: var(--bad-fg);\">Failed: ${escapeHtml(e.message)}</div>`;\n          }\n        });\n      });\n    } catch (e) {\n      statusContainer.innerHTML = `<div class=\"panel-empty\" style=\"color: var(--bad-fg);\">Failed to load health status: ${escapeHtml(e.message)}</div>`;\n    }\n  }\n\n  async function loadIncidents() {\n    try {\n      const [openRes, histRes] = await Promise.all([\n        fetch('/api/v1/health-checks/incidents'),\n        fetch('/api/v1/health-checks/incidents/history?limit=50')\n      ]);\n      const openData = await openRes.json();\n      const histData = await histRes.json();\n      let html = '';\n\n      // Open incidents\n      const open = (openData.success && openData.incidents) ? openData.incidents : [];\n      if (open.length > 0) {\n        html += '<div style=\"margin-bottom: 16px;\"><h4 style=\"color: var(--bad-fg); margin: 0 0 8px;\">Open Incidents (' + open.length + ')</h4>';\n        for (const inc of open) {\n          html += `<div style=\"padding: 10px 12px; margin-bottom: 8px; border: 1px solid var(--bad-fg)30; border-radius: 8px; background: var(--bad-bg);\">\n            <div style=\"display: flex; justify-content: space-between; align-items: center;\">\n              <span style=\"font-weight: 500;\">${escapeHtml(inc.serviceId)}</span>\n              <span>${severityBadge(inc.severity)}</span>\n            </div>\n            <div style=\"font-size: 0.82rem; color: var(--muted); margin-top: 4px;\">${escapeHtml(inc.message)}</div>\n            <div style=\"font-size: 0.75rem; color: var(--muted); margin-top: 4px;\">Started ${timeAgo(inc.createdAt)} \u00B7 ${inc.occurrences || 1} occurrence(s)</div>\n          </div>`;\n        }\n        html += '</div>';\n      } else {\n        html += '<div style=\"padding: 12px; margin-bottom: 16px; border: 1px solid var(--ok-fg)30; border-radius: 8px; background: var(--ok-bg); text-align: center; color: var(--ok-fg); font-size: 0.9rem;\">All services operational \u2014 no open incidents</div>';\n      }\n\n      // Incident history\n      const history = (histData.success && histData.history) ? histData.history : [];\n      if (history.length > 0) {\n        html += '<h4 style=\"margin: 0 0 8px; color: var(--muted);\">Incident History</h4>';\n        html += '<table style=\"width: 100%; border-collapse: collapse; font-size: 0.82rem;\">';\n        html += '<tr style=\"border-bottom: 1px solid var(--border); color: var(--muted);\"><th style=\"padding: 6px; text-align: left;\">Service</th><th style=\"padding: 6px; text-align: left;\">Type</th><th style=\"padding: 6px; text-align: left;\">Severity</th><th style=\"padding: 6px; text-align: left;\">Status</th><th style=\"padding: 6px; text-align: left;\">Duration</th><th style=\"padding: 6px; text-align: left;\">When</th></tr>';\n        for (const inc of history) {\n          const resolved = inc.status === 'resolved';\n          const dur = resolved && inc.duration ? (inc.duration < 60000 ? Math.round(inc.duration / 1000) + 's' : Math.round(inc.duration / 60000) + 'm') : '-';\n          html += `<tr style=\"border-bottom: 1px solid var(--border);\">`;\n          html += `<td style=\"padding: 6px;\">${escapeHtml(inc.serviceId)}</td>`;\n          html += `<td style=\"padding: 6px;\">${escapeHtml(inc.type)}</td>`;\n          html += `<td style=\"padding: 6px;\">${severityBadge(inc.severity)}</td>`;\n          html += `<td style=\"padding: 6px;\"><span style=\"color: ${resolved ? 'var(--ok-fg)' : 'var(--bad-fg)'};\">${inc.status}</span></td>`;\n          html += `<td style=\"padding: 6px;\">${dur}</td>`;\n          html += `<td style=\"padding: 6px; color: var(--muted);\">${timeAgo(inc.createdAt)}</td>`;\n          html += '</tr>';\n        }\n        html += '</table>';\n      }\n\n      incidentsContainer.innerHTML = html || '<div class=\"panel-empty\"><span class=\"empty-icon\">\uD83D\uDEA8</span>No incidents recorded yet.</div>';\n    } catch (e) {\n      incidentsContainer.innerHTML = `<div class=\"panel-empty\" style=\"color: var(--bad-fg);\">Failed: ${escapeHtml(e.message)}</div>`;\n    }\n  }\n\n  async function loadConfig() {\n    try {\n      const res = await fetch('/api/v1/health-checks/status');\n      const data = await res.json();\n      const services = data.success && data.status ? Object.values(data.status) : [];\n      if (services.length === 0) {\n        configContainer.innerHTML = '<div class=\"panel-empty\"><span class=\"empty-icon\">\u2699\uFE0F</span>No health checks configured yet. Click \"Add Health Check\" below.</div>';\n        return;\n      }\n      let html = '<table style=\"width: 100%; border-collapse: collapse; font-size: 0.85rem;\">';\n      html += '<tr style=\"border-bottom: 1px solid var(--border); color: var(--muted);\"><th style=\"padding: 8px; text-align: left;\">Service</th><th style=\"padding: 8px; text-align: left;\">Status</th><th style=\"padding: 8px; text-align: left;\">SLA Target</th><th style=\"padding: 8px; text-align: right;\">Actions</th></tr>';\n      for (const s of services) {\n        const isUp = s.status === 'up';\n        html += `<tr style=\"border-bottom: 1px solid var(--border);\">`;\n        html += `<td style=\"padding: 8px; font-weight: 500;\">${escapeHtml(s.name || s.serviceId)}</td>`;\n        html += `<td style=\"padding: 8px; color: ${isUp ? 'var(--ok-fg)' : 'var(--bad-fg)'};\">${isUp ? 'Up' : 'Down'}</td>`;\n        html += `<td style=\"padding: 8px;\">${s.sla?.target ? s.sla.target + '%' : '-'}</td>`;\n        html += `<td style=\"padding: 8px; text-align: right;\">`;\n        html += `<button onclick=\"document.dispatchEvent(new CustomEvent('health-edit', {detail:'${escapeHtml(s.serviceId)}'}))\" style=\"padding: 4px 10px; font-size: 0.78rem; margin-right: 4px;\">Edit</button>`;\n        html += `<button onclick=\"document.dispatchEvent(new CustomEvent('health-delete', {detail:'${escapeHtml(s.serviceId)}'}))\" style=\"padding: 4px 10px; font-size: 0.78rem; color: var(--bad-fg); border-color: var(--bad-fg);\">Delete</button>`;\n        html += '</td></tr>';\n      }\n      html += '</table>';\n      configContainer.innerHTML = html;\n    } catch (e) {\n      configContainer.innerHTML = `<div class=\"panel-empty\" style=\"color: var(--bad-fg);\">Failed: ${escapeHtml(e.message)}</div>`;\n    }\n  }\n\n  function showForm(id, name, url, timeout, codes, sla, slow) {\n    editingId = id || null;\n    formTitle.textContent = id ? 'Edit Health Check' : 'Add Health Check';\n    document.getElementById('health-form-id').value = id || '';\n    document.getElementById('health-form-id').disabled = !!id;\n    document.getElementById('health-form-name').value = name || '';\n    document.getElementById('health-form-url').value = url || '';\n    document.getElementById('health-form-timeout').value = timeout || 10000;\n    document.getElementById('health-form-codes').value = codes || '200';\n    document.getElementById('health-form-sla').value = sla || 99.9;\n    document.getElementById('health-form-slow').value = slow || 5000;\n    formEl.style.display = '';\n    addBtn.style.display = 'none';\n  }\n\n  function hideForm() {\n    formEl.style.display = 'none';\n    addBtn.style.display = '';\n    editingId = null;\n  }\n\n  addBtn?.addEventListener('click', () => showForm('', '', '', 10000, '200', 99.9, 5000));\n  formCancel?.addEventListener('click', hideForm);\n\n  formSave?.addEventListener('click', async () => {\n    const id = editingId || document.getElementById('health-form-id').value.trim();\n    if (!id) return showNotification('Service ID is required', 'warning');\n    const url = document.getElementById('health-form-url').value.trim();\n    if (!url) return showNotification('URL is required', 'warning');\n\n    const codes = document.getElementById('health-form-codes').value.split(',').map(c => parseInt(c.trim())).filter(Boolean);\n    const body = {\n      name: document.getElementById('health-form-name').value.trim() || id,\n      url,\n      timeout: parseInt(document.getElementById('health-form-timeout').value) || 10000,\n      expectedStatusCodes: codes.length ? codes : [200],\n      sla: { target: parseFloat(document.getElementById('health-form-sla').value) || 99.9 },\n      slowResponseThreshold: parseInt(document.getElementById('health-form-slow').value) || 5000\n    };\n\n    try {\n      formSave.textContent = 'Saving...';\n      formSave.disabled = true;\n      const res = await secureFetch(`/api/v1/health-checks/${encodeURIComponent(id)}/configure`, {\n        method: 'POST',\n        headers: { 'Content-Type': 'application/json' },\n        body: JSON.stringify(body)\n      });\n      const data = await res.json();\n      if (!data.success) throw new Error(data.error || 'Save failed');\n      hideForm();\n      loadConfig();\n      loadStatus();\n    } catch (e) {\n      showNotification('Error: ' + e.message, 'error');\n    } finally {\n      formSave.textContent = 'Save';\n      formSave.disabled = false;\n    }\n  });\n\n  document.addEventListener('health-edit', async (e) => {\n    const id = e.detail;\n    // Load existing config to populate form \u2014 use current status data as fallback\n    showForm(id, '', '', 10000, '200', 99.9, 5000);\n  });\n\n  document.addEventListener('health-delete', async (e) => {\n    const id = e.detail;\n    if (!confirm(`Delete health check for \"${id}\"?`)) return;\n    try {\n      const res = await secureFetch(`/api/v1/health-checks/${encodeURIComponent(id)}/configure`, { method: 'DELETE' });\n      const data = await res.json();\n      if (!data.success) throw new Error(data.error);\n      loadConfig();\n      loadStatus();\n    } catch (err) {\n      showNotification('Error: ' + err.message, 'error');\n    }\n  });\n\n  openBtn?.addEventListener('click', () => {\n    modal?.classList.add('show');\n    loadStatus();\n  });\n  wireModal(modal, cancelBtn);\n  refreshBtn?.addEventListener('click', loadStatus);\n\n  // Lazy-load tabs\n  document.querySelector('[data-panel=\"health-incidents\"]')?.addEventListener('click', loadIncidents);\n  document.querySelector('[data-panel=\"health-config\"]')?.addEventListener('click', loadConfig);\n})();\n;\n// ========== UPDATE MANAGEMENT ==========\n(function() {\n  // Inject modal HTML\n  injectModal('updates-modal', `<div id=\"updates-modal\" class=\"weather-modal\">\n    <div class=\"weather-modal-content\" style=\"min-width: 750px; max-width: 950px;\">\n      <h3>\u2B06\uFE0F Update Management</h3>\n      <p class=\"modal-subtitle\">\n        Check for container image updates, apply them, and manage rollbacks.\n      </p>\n\n      <div class=\"panel-tabs\">\n        <button class=\"panel-tab active\" data-panel=\"updates-available\">Available</button>\n        <button class=\"panel-tab\" data-panel=\"updates-history\">History</button>\n        <button class=\"panel-tab\" data-panel=\"updates-auto\">Auto-Update</button>\n        <button class=\"panel-tab\" data-panel=\"updates-dashcaddy\" id=\"updates-dashcaddy-tab\">DashCaddy</button>\n      </div>\n\n      <!-- Tab: Available Updates -->\n      <div id=\"updates-available\" class=\"panel-section active\">\n        <div style=\"margin-bottom: 12px; display: flex; gap: 8px; align-items: center;\">\n          <button id=\"updates-check-btn\" class=\"btn-accent-solid\">\uD83D\uDD0D Check for Updates</button>\n          <button id=\"updates-update-all-btn\" style=\"display: none; padding: 6px 14px; font-size: 0.82rem; background: #f97316; color: #fff; border: 1px solid #f97316; border-radius: 6px; cursor: pointer;\">\u2B06\uFE0F Update All</button>\n          <span id=\"updates-count-badge\" style=\"display: none; padding: 4px 10px; border-radius: 12px; font-size: 0.78rem; font-weight: 600; background: var(--accent); color: var(--bg);\"></span>\n        </div>\n        <div id=\"updates-available-container\" style=\"max-height: 450px; overflow-y: auto;\">\n          <div class=\"panel-empty\"><span class=\"empty-icon\">\uD83D\uDCE6</span> Click \"Check for Updates\" to scan containers.</div>\n        </div>\n      </div>\n\n      <!-- Tab: History -->\n      <div id=\"updates-history\" class=\"panel-section\">\n        <div id=\"updates-history-container\" class=\"scroll-container\">\n          <div class=\"panel-empty\"><span class=\"brand-spinner\"></span> Loading update history...</div>\n        </div>\n      </div>\n\n      <!-- Tab: Auto-Update -->\n      <div id=\"updates-auto\" class=\"panel-section\">\n        <div id=\"updates-auto-container\" class=\"scroll-container\">\n          <div class=\"panel-empty\"><span class=\"empty-icon\">\uD83E\uDD16</span> Loading auto-update configuration...</div>\n        </div>\n      </div>\n\n      <!-- Tab: DashCaddy Self-Update -->\n      <div id=\"updates-dashcaddy\" class=\"panel-section\">\n        <div id=\"dashcaddy-version-info\" style=\"display: flex; align-items: center; gap: 16px; margin-bottom: 16px; padding: 12px; border-radius: 8px; background: var(--bg);\">\n          <div style=\"flex: 1;\">\n            <div style=\"font-weight: 600; font-size: 1rem;\">DashCaddy</div>\n            <div id=\"dashcaddy-current-version\" style=\"color: var(--muted); font-size: 0.85rem;\">Loading...</div>\n          </div>\n          <div id=\"dashcaddy-update-badge\" style=\"display: none; padding: 4px 12px; border-radius: 12px; font-size: 0.78rem; font-weight: 600; background: var(--accent); color: var(--bg);\">Update available</div>\n        </div>\n        <div id=\"dashcaddy-update-details\" style=\"display: none; margin-bottom: 16px; padding: 12px; border-radius: 8px; border: 1px solid var(--border);\">\n          <div style=\"display: flex; justify-content: space-between; align-items: center; margin-bottom: 8px;\">\n            <span style=\"font-weight: 600;\">New version: <span id=\"dashcaddy-new-version\"></span></span>\n            <button id=\"dashcaddy-apply-btn\" class=\"btn-accent-solid\" style=\"padding: 6px 16px; font-size: 0.85rem;\">Update Now</button>\n          </div>\n          <div id=\"dashcaddy-changelog\" style=\"font-size: 0.8rem; color: var(--muted); max-height: 120px; overflow-y: auto; white-space: pre-wrap; font-family: var(--font-mono); line-height: 1.5;\"></div>\n        </div>\n        <div id=\"dashcaddy-status-bar\" style=\"display: none; margin-bottom: 16px; padding: 10px 12px; border-radius: 8px; font-size: 0.85rem;\"></div>\n        <div style=\"margin-bottom: 12px;\">\n          <button id=\"dashcaddy-check-btn\" style=\"padding: 6px 14px; font-size: 0.82rem;\">Check for Updates</button>\n          <button id=\"dashcaddy-rollback-btn\" style=\"padding: 6px 14px; font-size: 0.82rem; margin-left: 6px;\">Rollback</button>\n        </div>\n        <div id=\"dashcaddy-history-container\" style=\"max-height: 250px; overflow-y: auto;\">\n          <div class=\"panel-empty\"><span class=\"empty-icon\">\uD83D\uDCE6</span>No self-update history.</div>\n        </div>\n      </div>\n\n      <div class=\"panel-bottom-bar\">\n        <span id=\"updates-last-check\" class=\"text-auto-right\"></span>\n      </div>\n\n      <div class=\"weather-modal-buttons modal-footer-bar\">\n        <button id=\"updates-cancel\">Close</button>\n      </div>\n    </div>\n  </div>`);\n\n  const modal = document.getElementById('updates-modal');\n  const openBtn = document.getElementById('updates-btn');\n  const cancelBtn = document.getElementById('updates-cancel');\n  const checkBtn = document.getElementById('updates-check-btn');\n  const availableContainer = document.getElementById('updates-available-container');\n  const historyContainer = document.getElementById('updates-history-container');\n  const autoContainer = document.getElementById('updates-auto-container');\n  const lastCheckSpan = document.getElementById('updates-last-check');\n\n  async function loadAvailable() {\n    try {\n      const res = await fetch('/api/v1/updates/available');\n      const data = await res.json();\n      if (!data.success) throw new Error(data.error);\n\n      const updates = data.updates || [];\n      if (updates.length === 0) {\n        availableContainer.innerHTML = '<div class=\"panel-empty\"><span class=\"empty-icon\">\u2705</span>All containers are up to date.</div>';\n        lastCheckSpan.textContent = '';\n        document.getElementById('updates-update-all-btn').style.display = 'none';\n        document.getElementById('updates-count-badge').style.display = 'none';\n        window._pendingUpdates = [];\n        return;\n      }\n\n      let html = '<table style=\"width: 100%; border-collapse: collapse; font-size: 0.85rem;\">';\n      html += '<tr style=\"border-bottom: 1px solid var(--border); color: var(--muted);\"><th style=\"padding: 8px; text-align: left;\">Container</th><th style=\"padding: 8px; text-align: left;\">Image</th><th style=\"padding: 8px; text-align: left;\">Current</th><th style=\"padding: 8px; text-align: left;\">Latest</th><th style=\"padding: 8px; text-align: right;\">Actions</th></tr>';\n      for (const u of updates) {\n        // Match app by containerId first, then name\n        const appId = (() => {\n          const apps = window.APPS || [];\n          for (const a of apps) {\n            if (a.containerId === u.containerId || a.name === u.containerName || a.id === u.containerName) return a.id;\n          }\n          return u.containerName;\n        })();\n        html += `<tr data-app-id=\"${escapeHtml(appId)}\" style=\"border-bottom: 1px solid var(--border);\">`;\n        html += `<td style=\"padding: 8px; font-weight: 500;\">${escapeHtml(u.containerName)}</td>`;\n        html += `<td style=\"padding: 8px; color: var(--muted);\">${escapeHtml(u.imageName)}</td>`;\n        html += `<td style=\"padding: 8px;\"><code style=\"font-size: 0.78rem; background: var(--bg); padding: 2px 6px; border-radius: 4px;\">${escapeHtml(u.currentDigest)}</code></td>`;\n        html += `<td style=\"padding: 8px;\"><code style=\"font-size: 0.78rem; background: var(--ok-bg); color: var(--ok-fg); padding: 2px 6px; border-radius: 4px;\">${escapeHtml(u.latestDigest)}</code></td>`;\n        html += `<td style=\"padding: 8px; text-align: right;\">`;\n        html += `<button class=\"update-now-btn\" data-id=\"${escapeHtml(u.containerId)}\" data-name=\"${escapeHtml(u.containerName)}\" style=\"padding: 4px 10px; font-size: 0.78rem; background: var(--accent); color: var(--bg); border-color: var(--accent); margin-right: 4px;\">Update</button>`;\n        html += `<button class=\"rollback-btn\" data-id=\"${escapeHtml(u.containerId)}\" data-name=\"${escapeHtml(u.containerName)}\" style=\"padding: 4px 10px; font-size: 0.78rem;\">Rollback</button>`;\n        html += '</td></tr>';\n      }\n      html += '</table>';\n      availableContainer.innerHTML = html;\n      lastCheckSpan.textContent = updates.length + ' update(s) available';\n\n      // Show count badge and Update All button\n      const countBadge = document.getElementById('updates-count-badge');\n      const updateAllBtn = document.getElementById('updates-update-all-btn');\n      if (countBadge) {\n        countBadge.textContent = updates.length + ' pending';\n        countBadge.style.display = '';\n      }\n      if (updateAllBtn && updates.length > 0) {\n        updateAllBtn.style.display = '';\n      }\n\n      // Store updates for Update All button\n      window._pendingUpdates = updates;\n\n      // Wire update buttons\n      availableContainer.querySelectorAll('.update-now-btn').forEach(btn => {\n        btn.addEventListener('click', async () => {\n          const id = btn.dataset.id;\n          const name = btn.dataset.name;\n          if (!confirm(`Update \"${name}\" to the latest version? The container will restart.`)) return;\n          btn.textContent = 'Updating...';\n          btn.disabled = true;\n          try {\n            const r = await secureFetch(`/api/v1/updates/update/${encodeURIComponent(id)}`, {\n              method: 'POST',\n              headers: { 'Content-Type': 'application/json' },\n              body: JSON.stringify({ autoRollback: true })\n            });\n            const d = await r.json();\n            if (d.success) {\n              btn.textContent = 'Done!';\n              btn.style.background = 'var(--ok-fg)';\n              setTimeout(() => loadAvailable(), 2000);\n            } else {\n              throw new Error(d.error || 'Update failed');\n            }\n          } catch (e) {\n            btn.textContent = 'Failed';\n            btn.style.color = 'var(--bad-fg)';\n            showNotification('Update error: ' + e.message, 'error');\n            setTimeout(() => { btn.textContent = 'Update'; btn.disabled = false; btn.style.color = ''; btn.style.background = ''; }, 3000);\n          }\n        });\n      });\n\n      // Wire rollback buttons\n      availableContainer.querySelectorAll('.rollback-btn').forEach(btn => {\n        btn.addEventListener('click', async () => {\n          const id = btn.dataset.id;\n          const name = btn.dataset.name;\n          if (!confirm(`Rollback \"${name}\" to its previous version?`)) return;\n          btn.textContent = 'Rolling back...';\n          btn.disabled = true;\n          try {\n            const r = await secureFetch(`/api/v1/updates/rollback/${encodeURIComponent(id)}`, { method: 'POST' });\n            const d = await r.json();\n            if (d.success) {\n              btn.textContent = 'Rolled back!';\n              setTimeout(() => loadAvailable(), 2000);\n            } else {\n              throw new Error(d.error || 'Rollback failed');\n            }\n          } catch (e) {\n            btn.textContent = 'Failed';\n            showNotification('Rollback error: ' + e.message, 'error');\n            setTimeout(() => { btn.textContent = 'Rollback'; btn.disabled = false; }, 3000);\n          }\n        });\n      });\n    } catch (e) {\n      availableContainer.innerHTML = `<div class=\"panel-empty\" style=\"color: var(--bad-fg);\">Failed: ${escapeHtml(e.message)}</div>`;\n    }\n  }\n\n  // Update All \u2014 sequentially, skip failures\n  async function updateAllContainers() {\n    const updates = window._pendingUpdates || [];\n    if (!updates.length) return;\n    const btn = document.getElementById('updates-update-all-btn');\n    if (!confirm(`Update all ${updates.length} containers? Each will restart.`)) return;\n    btn.textContent = '\u23F3 Updating...';\n    btn.disabled = true;\n    let success = 0, failed = 0;\n    for (const u of updates) {\n      try {\n        const r = await secureFetch(`/api/v1/updates/update/${encodeURIComponent(u.containerId)}`, {\n          method: 'POST',\n          headers: { 'Content-Type': 'application/json' },\n          body: JSON.stringify({ autoRollback: true })\n        });\n        const d = await r.json();\n        if (d.success) success++;\n        else failed++;\n      } catch (_) { failed++; }\n    }\n    btn.textContent = `\u2705 Done`;\n    showNotification(`Update all: ${success} succeeded, ${failed} failed.`, success > 0 && failed === 0 ? 'success' : 'error');\n    setTimeout(() => {\n      btn.textContent = '\u2B06\uFE0F Update All';\n      btn.disabled = false;\n      loadAvailable();\n    }, 3000);\n  }\n\n  document.getElementById('updates-update-all-btn')?.addEventListener('click', updateAllContainers);\n\n  async function checkForUpdates() {\n    checkBtn.textContent = '\uD83D\uDD0D Checking...';\n    checkBtn.disabled = true;\n    try {\n      const res = await secureFetch('/api/v1/updates/check', { method: 'POST' });\n      const data = await res.json();\n      if (!data.success) throw new Error(data.error);\n      checkBtn.textContent = '\u2705 Done!';\n      await loadAvailable();\n    } catch (e) {\n      checkBtn.textContent = '\u274C Failed';\n      showNotification('Check error: ' + e.message, 'error');\n    }\n    setTimeout(() => { checkBtn.textContent = '\uD83D\uDD0D Check for Updates'; checkBtn.disabled = false; }, 3000);\n  }\n\n  async function loadHistory() {\n    try {\n      historyContainer.innerHTML = '<div class=\"panel-empty\"><span class=\"brand-spinner\"></span> Loading...</div>';\n      const res = await fetch('/api/v1/updates/history?limit=50');\n      const data = await res.json();\n      const history = data.success && data.history ? data.history : [];\n      if (history.length === 0) {\n        historyContainer.innerHTML = '<div class=\"panel-empty\"><span class=\"empty-icon\">\uD83D\uDCCB</span>No update history yet.</div>';\n        return;\n      }\n      let html = '<table style=\"width: 100%; border-collapse: collapse; font-size: 0.82rem;\">';\n      html += '<tr style=\"border-bottom: 1px solid var(--border); color: var(--muted);\"><th style=\"padding: 6px; text-align: left;\">When</th><th style=\"padding: 6px; text-align: left;\">Container</th><th style=\"padding: 6px; text-align: left;\">Image</th><th style=\"padding: 6px; text-align: left;\">Duration</th><th style=\"padding: 6px; text-align: left;\">Status</th></tr>';\n      for (const h of history) {\n        const ok = h.status === 'success';\n        const dur = h.duration ? (h.duration < 1000 ? h.duration + 'ms' : Math.round(h.duration / 1000) + 's') : '-';\n        html += `<tr style=\"border-bottom: 1px solid var(--border);\">`;\n        html += `<td style=\"padding: 6px; color: var(--muted);\">${timeAgo(h.timestamp)}</td>`;\n        html += `<td style=\"padding: 6px; font-weight: 500;\">${escapeHtml(h.containerName)}</td>`;\n        html += `<td style=\"padding: 6px; color: var(--muted);\">${escapeHtml(h.imageName)}</td>`;\n        html += `<td style=\"padding: 6px;\">${dur}</td>`;\n        html += `<td style=\"padding: 6px;\"><span style=\"color: ${ok ? 'var(--ok-fg)' : 'var(--bad-fg)'};\">${ok ? '\u2713 success' : '\u2717 failed'}</span></td>`;\n        html += '</tr>';\n        if (!ok && h.error) {\n          html += `<tr><td colspan=\"5\" style=\"padding: 4px 6px 8px; font-size: 0.78rem; color: var(--bad-fg);\">${escapeHtml(h.error)}</td></tr>`;\n        }\n      }\n      html += '</table>';\n      historyContainer.innerHTML = html;\n    } catch (e) {\n      historyContainer.innerHTML = `<div class=\"panel-empty\" style=\"color: var(--bad-fg);\">Failed: ${escapeHtml(e.message)}</div>`;\n    }\n  }\n\n  async function loadAutoConfig() {\n    try {\n      autoContainer.innerHTML = '<div class=\"panel-empty\"><span class=\"brand-spinner\"></span> Loading...</div>';\n\n      // Fetch containers and saved auto-update config in parallel\n      const [containersRes, configRes] = await Promise.all([\n        fetch('/api/v1/stats/containers'),\n        fetch('/api/v1/updates/auto-update')\n      ]);\n      const containersData = await containersRes.json();\n      const configData = await configRes.json();\n\n      const containers = containersData.success && containersData.stats ? containersData.stats : [];\n      const savedConfig = configData.success && configData.config ? configData.config : {};\n\n      if (containers.length === 0) {\n        autoContainer.innerHTML = '<div class=\"panel-empty\"><span class=\"empty-icon\">\uD83E\uDD16</span>No running containers found.</div>';\n        return;\n      }\n\n      let html = '<div style=\"margin-bottom: 12px; font-size: 0.8rem; color: var(--muted);\">Auto-updates run during maintenance window (default 2AM-4AM). Daily = every day, Weekly = Sundays, Monthly = 1st of month.</div>';\n      html += '<table style=\"width: 100%; border-collapse: collapse; font-size: 0.85rem;\">';\n      html += '<tr style=\"border-bottom: 1px solid var(--border); color: var(--muted);\"><th style=\"padding: 8px; text-align: left;\">Container</th><th style=\"padding: 8px; text-align: left;\">Schedule</th><th style=\"padding: 8px; text-align: left;\">Window</th><th style=\"padding: 8px; text-align: left;\">Rollback</th><th style=\"padding: 8px; text-align: left;\">Last Run</th><th style=\"padding: 8px; text-align: right;\">Actions</th></tr>';\n      for (const c of containers) {\n        const name = c.name || c.Names?.[0]?.replace(/^\\//, '') || c.Id?.substring(0, 12);\n        const cid = c.containerId || c.Id;\n        const saved = savedConfig[cid] || {};\n        const scheduleVal = saved.enabled ? (saved.schedule || 'weekly') : '';\n        const rollbackVal = saved.autoRollback !== false;\n        const windowVal = saved.maintenanceWindow || '';\n        const lastRun = saved.lastAutoUpdate ? timeAgo(saved.lastAutoUpdate) : 'Never';\n\n        html += `<tr style=\"border-bottom: 1px solid var(--border);\" data-container-id=\"${escapeHtml(cid)}\">`;\n        html += `<td style=\"padding: 8px; font-weight: 500;\">${escapeHtml(name)}</td>`;\n        html += `<td style=\"padding: 8px;\">\n          <select class=\"auto-schedule\" data-id=\"${escapeHtml(cid)}\" style=\"padding: 4px 8px; border-radius: 4px; border: 1px solid var(--border); background: var(--bg); color: var(--fg); font-size: 0.82rem;\">\n            <option value=\"\"${!scheduleVal ? ' selected' : ''}>Disabled</option>\n            <option value=\"daily\"${scheduleVal === 'daily' ? ' selected' : ''}>Daily</option>\n            <option value=\"weekly\"${scheduleVal === 'weekly' ? ' selected' : ''}>Weekly</option>\n            <option value=\"monthly\"${scheduleVal === 'monthly' ? ' selected' : ''}>Monthly</option>\n          </select></td>`;\n        html += `<td style=\"padding: 8px;\"><input type=\"text\" class=\"auto-window\" data-id=\"${escapeHtml(cid)}\" value=\"${escapeHtml(windowVal)}\" placeholder=\"02:00-04:00\" style=\"width: 90px; padding: 3px 6px; font-size: 0.78rem; border: 1px solid var(--border); border-radius: 4px; background: var(--bg); color: var(--fg);\" /></td>`;\n        html += `<td style=\"padding: 8px;\"><input type=\"checkbox\" class=\"auto-rollback\" data-id=\"${escapeHtml(cid)}\"${rollbackVal ? ' checked' : ''} /></td>`;\n        html += `<td style=\"padding: 8px; font-size: 0.78rem; color: var(--muted);\">${lastRun}</td>`;\n        html += `<td style=\"padding: 8px; text-align: right;\"><button class=\"save-auto-btn\" data-id=\"${escapeHtml(cid)}\" data-name=\"${escapeHtml(name)}\" style=\"padding: 4px 10px; font-size: 0.78rem;\">Save</button></td>`;\n        html += '</tr>';\n      }\n      html += '</table>';\n      autoContainer.innerHTML = html;\n\n      // Wire save buttons\n      autoContainer.querySelectorAll('.save-auto-btn').forEach(btn => {\n        btn.addEventListener('click', async () => {\n          const id = btn.dataset.id;\n          const row = btn.closest('tr');\n          const schedule = row.querySelector('.auto-schedule').value;\n          const rollback = row.querySelector('.auto-rollback').checked;\n          const window = row.querySelector('.auto-window').value.trim();\n          btn.textContent = 'Saving...';\n          btn.disabled = true;\n          try {\n            const r = await secureFetch(`/api/v1/updates/auto-update/${encodeURIComponent(id)}`, {\n              method: 'POST',\n              headers: { 'Content-Type': 'application/json' },\n              body: JSON.stringify({ enabled: !!schedule, schedule: schedule || 'weekly', autoRollback: rollback, maintenanceWindow: window || undefined })\n            });\n            const d = await r.json();\n            if (d.success) {\n              btn.textContent = '\u2713 Saved';\n            } else {\n              throw new Error(d.error);\n            }\n          } catch (e) {\n            btn.textContent = '\u2717 Error';\n            showNotification('Save error: ' + e.message, 'error');\n          }\n          setTimeout(() => { btn.textContent = 'Save'; btn.disabled = false; }, 2000);\n        });\n      });\n    } catch (e) {\n      autoContainer.innerHTML = `<div class=\"panel-empty\" style=\"color: var(--bad-fg);\">Failed: ${escapeHtml(e.message)}</div>`;\n    }\n  }\n\n  // ===== DASHCADDY SELF-UPDATE =====\n\n  const dcVersionInfo = document.getElementById('dashcaddy-current-version');\n  const dcUpdateBadge = document.getElementById('dashcaddy-update-badge');\n  const dcUpdateDetails = document.getElementById('dashcaddy-update-details');\n  const dcNewVersion = document.getElementById('dashcaddy-new-version');\n  const dcChangelog = document.getElementById('dashcaddy-changelog');\n  const dcApplyBtn = document.getElementById('dashcaddy-apply-btn');\n  const dcCheckBtn = document.getElementById('dashcaddy-check-btn');\n  const dcRollbackBtn = document.getElementById('dashcaddy-rollback-btn');\n  const dcStatusBar = document.getElementById('dashcaddy-status-bar');\n  const dcHistoryContainer = document.getElementById('dashcaddy-history-container');\n\n  let dcLastCheck = null;\n\n  function dcShowStatus(msg, type) {\n    if (!dcStatusBar) return;\n    dcStatusBar.style.display = 'block';\n    dcStatusBar.style.background = type === 'error' ? 'var(--bad-bg)' : type === 'success' ? 'var(--ok-bg)' : 'var(--bg)';\n    dcStatusBar.style.color = type === 'error' ? 'var(--bad-fg)' : type === 'success' ? 'var(--ok-fg)' : 'var(--fg)';\n    dcStatusBar.textContent = msg;\n  }\n\n  async function dcLoadVersion() {\n    try {\n      const res = await fetch('/api/v1/system/version');\n      const data = await res.json();\n      if (data.success) {\n        const commit = data.commit && data.commit !== 'unknown' ? data.commit : null;\n        dcVersionInfo.textContent = 'v' + data.version + (commit ? ' (' + commit.substring(0, 7) + ')' : '');\n      }\n    } catch (_) {\n      dcVersionInfo.textContent = 'Unable to fetch version';\n    }\n  }\n\n  async function dcCheckForUpdate(silent) {\n    if (!silent) {\n      dcCheckBtn.textContent = 'Checking...';\n      dcCheckBtn.disabled = true;\n    }\n    try {\n      const res = await fetch('/api/v1/system/update-check');\n      const data = await res.json();\n      dcLastCheck = data;\n\n      if (data.success && data.available && data.remote) {\n        dcUpdateBadge.style.display = '';\n        dcUpdateDetails.style.display = '';\n        dcNewVersion.textContent = 'v' + data.remote.version;\n        dcChangelog.textContent = data.remote.changelog || 'No changelog available.';\n\n        // Add notification dot to the Updates button\n        const updatesBtn = document.getElementById('updates-btn');\n        if (updatesBtn && !updatesBtn.querySelector('.update-dot')) {\n          const dot = document.createElement('span');\n          dot.className = 'update-dot';\n          dot.style.cssText = 'position:absolute;top:2px;right:2px;width:8px;height:8px;border-radius:50%;background:var(--accent);';\n          updatesBtn.style.position = 'relative';\n          updatesBtn.appendChild(dot);\n        }\n        // Also add dot to the DashCaddy tab\n        const dcTab = document.getElementById('updates-dashcaddy-tab');\n        if (dcTab && !dcTab.querySelector('.update-dot')) {\n          const dot = document.createElement('span');\n          dot.className = 'update-dot';\n          dot.style.cssText = 'display:inline-block;width:6px;height:6px;border-radius:50%;background:var(--accent);margin-left:4px;vertical-align:middle;';\n          dcTab.appendChild(dot);\n        }\n      } else {\n        dcUpdateBadge.style.display = 'none';\n        dcUpdateDetails.style.display = 'none';\n        await dcLoadVersion();\n        if (!silent) dcShowStatus('You are running the latest version.', 'success');\n      }\n\n      if (!silent) {\n        dcCheckBtn.textContent = 'Check for Updates';\n        dcCheckBtn.disabled = false;\n      }\n    } catch (e) {\n      if (!silent) {\n        dcShowStatus('Failed to check: ' + e.message, 'error');\n        dcCheckBtn.textContent = 'Check for Updates';\n        dcCheckBtn.disabled = false;\n      }\n    }\n  }\n\n  async function dcApplyUpdate() {\n    if (!confirm('Apply DashCaddy update? The API container will restart.')) return false;\n    dcApplyBtn.textContent = 'Updating...';\n    dcApplyBtn.disabled = true;\n    dcShowStatus('Downloading and applying update...', 'info');\n    try {\n      const res = await secureFetch('/api/v1/system/update-apply', { method: 'POST' });\n      const data = await res.json();\n      if (data.success) {\n        dcShowStatus('Update initiated: v' + (data.fromVersion || '?') + ' \u2192 v' + (data.toVersion || '?') + '. The container will restart shortly.', 'success');\n        dcApplyBtn.textContent = 'Applied!';\n        // Remove notification dots\n        document.querySelectorAll('.update-dot').forEach(d => d.remove());\n        return true;\n      } else {\n        throw new Error(data.error || 'Update failed');\n      }\n    } catch (e) {\n      dcShowStatus('Update failed: ' + e.message, 'error');\n      dcApplyBtn.textContent = 'Update Now';\n      dcApplyBtn.disabled = false;\n      throw e;\n    }\n  }\n\n  async function dcLoadHistory() {\n    try {\n      const res = await fetch('/api/v1/system/update-history');\n      const data = await res.json();\n      const history = data.success && data.history ? data.history : [];\n      if (history.length === 0) {\n        dcHistoryContainer.innerHTML = '<div class=\"panel-empty\"><span class=\"empty-icon\">\uD83D\uDCE6</span>No self-update history.</div>';\n        return;\n      }\n      let html = '<table style=\"width: 100%; border-collapse: collapse; font-size: 0.82rem;\">';\n      html += '<tr style=\"border-bottom: 1px solid var(--border); color: var(--muted);\"><th style=\"padding: 6px; text-align: left;\">When</th><th style=\"padding: 6px; text-align: left;\">Version</th><th style=\"padding: 6px; text-align: left;\">From</th><th style=\"padding: 6px; text-align: left;\">Status</th></tr>';\n      for (const h of history) {\n        const st = h.status === 'success' ? '\u2713 success' : h.status === 'pending' ? '\u23F3 pending' : h.status === 'partial' ? '\u26A0 partial' : '\u2717 ' + h.status;\n        const stColor = h.status === 'success' ? 'var(--ok-fg)' : h.status === 'pending' ? 'var(--muted)' : 'var(--bad-fg)';\n        html += '<tr style=\"border-bottom: 1px solid var(--border);\">';\n        html += '<td style=\"padding: 6px; color: var(--muted);\">' + timeAgo(h.timestamp) + '</td>';\n        html += '<td style=\"padding: 6px; font-weight: 500;\">v' + escapeHtml(h.version) + (h.rollback ? ' (rollback)' : '') + '</td>';\n        html += '<td style=\"padding: 6px; color: var(--muted);\">v' + escapeHtml(h.fromVersion || '?') + '</td>';\n        html += '<td style=\"padding: 6px;\"><span style=\"color: ' + stColor + ';\">' + st + '</span></td>';\n        html += '</tr>';\n        if (h.error) {\n          html += '<tr><td colspan=\"4\" style=\"padding: 4px 6px 8px; font-size: 0.78rem; color: var(--bad-fg);\">' + escapeHtml(h.error) + '</td></tr>';\n        }\n        if (h.note) {\n          html += '<tr><td colspan=\"4\" style=\"padding: 4px 6px 8px; font-size: 0.78rem; color: var(--muted);\">' + escapeHtml(h.note) + '</td></tr>';\n        }\n      }\n      html += '</table>';\n      dcHistoryContainer.innerHTML = html;\n    } catch (e) {\n      dcHistoryContainer.innerHTML = '<div class=\"panel-empty\" style=\"color: var(--bad-fg);\">Failed: ' + escapeHtml(e.message) + '</div>';\n    }\n  }\n\n  async function dcShowRollback() {\n    try {\n      const res = await fetch('/api/v1/system/rollback-versions');\n      const data = await res.json();\n      const versions = data.success && data.versions ? data.versions : [];\n      if (versions.length === 0) {\n        showNotification('No rollback versions available.', 'info');\n        return;\n      }\n      const version = prompt('Available rollback versions:\\n' + versions.join('\\n') + '\\n\\nEnter version to rollback to:');\n      if (!version) return;\n      if (!versions.includes(version)) {\n        showNotification('Invalid version: ' + version, 'error');\n        return;\n      }\n      if (!confirm('Rollback DashCaddy to v' + version + '? The container will restart.')) return;\n      dcShowStatus('Rolling back to v' + version + '...', 'info');\n      const r = await secureFetch('/api/v1/system/rollback', {\n        method: 'POST',\n        headers: { 'Content-Type': 'application/json' },\n        body: JSON.stringify({ version })\n      });\n      const d = await r.json();\n      if (d.success) {\n        dcShowStatus('Rollback to v' + version + ' initiated. Container will restart.', 'success');\n      } else {\n        throw new Error(d.error || 'Rollback failed');\n      }\n    } catch (e) {\n      dcShowStatus('Rollback failed: ' + e.message, 'error');\n    }\n  }\n\n  dcCheckBtn?.addEventListener('click', () => dcCheckForUpdate(false));\n  dcApplyBtn?.addEventListener('click', () => dcApplyUpdate().catch(() => {}));\n  dcRollbackBtn?.addEventListener('click', dcShowRollback);\n\n  checkBtn?.addEventListener('click', checkForUpdates);\n  openBtn?.addEventListener('click', () => {\n    modal?.classList.add('show');\n    loadAvailable();\n  });\n  wireModal(modal, cancelBtn);\n\n  // Open Update Management modal, optionally scrolled to a specific app\n  window.openUpdateModal = function(appId) {\n    modal?.classList.add('show');\n    loadAvailable().then(() => {\n      if (!appId) return;\n      // Scroll to and highlight the matching row\n      const row = availableContainer.querySelector(`[data-app-id=\"${appId}\"]`);\n      if (row) {\n        row.scrollIntoView({ behavior: 'smooth', block: 'center' });\n        row.style.background = 'rgba(249,115,22,0.15)';\n        setTimeout(() => { row.style.background = ''; }, 3000);\n      }\n    });\n  };\n\n  // Lazy-load tabs\n  document.querySelector('[data-panel=\"updates-history\"]')?.addEventListener('click', loadHistory);\n  document.querySelector('[data-panel=\"updates-auto\"]')?.addEventListener('click', loadAutoConfig);\n  document.querySelector('[data-panel=\"updates-dashcaddy\"]')?.addEventListener('click', () => {\n    dcLoadVersion();\n    dcLoadHistory();\n    if (!dcLastCheck) dcCheckForUpdate(true);\n  });\n\n  window.dcApplyUpdate = dcApplyUpdate;\n  window.dcCheckForUpdate = dcCheckForUpdate;\n\n  // Non-blocking check on page load \u2014 just adds notification dot if update available\n  setTimeout(() => dcCheckForUpdate(true), 5000);\n})();\n;\n// ========== DOCKER RESOURCES (Volumes, Networks, Disk Usage) ==========\n(function() {\n  injectModal('docker-resources-modal', `<div id=\"docker-resources-modal\" class=\"weather-modal\">\n    <div class=\"weather-modal-content\" style=\"min-width: 750px; max-width: 950px;\">\n      <h3>\uD83D\uDC33 Docker Resources</h3>\n      <p class=\"modal-subtitle\">Manage volumes, networks, and view disk usage.</p>\n\n      <div class=\"panel-tabs\">\n        <button class=\"panel-tab active\" data-panel=\"dr-volumes\">Volumes</button>\n        <button class=\"panel-tab\" data-panel=\"dr-networks\">Networks</button>\n        <button class=\"panel-tab\" data-panel=\"dr-disk\">Disk Usage</button>\n      </div>\n\n      <!-- Volumes -->\n      <div id=\"dr-volumes\" class=\"panel-section active\">\n        <div style=\"display: flex; gap: 8px; margin-bottom: 12px;\">\n          <input type=\"text\" id=\"dr-vol-name\" placeholder=\"Volume name\" style=\"flex: 1; padding: 6px 10px; border: 1px solid var(--border); border-radius: 6px; background: var(--bg); color: var(--fg);\" />\n          <button id=\"dr-vol-create\" class=\"btn-accent-solid\" style=\"padding: 6px 14px; font-size: 0.82rem;\">Create</button>\n        </div>\n        <div id=\"dr-vol-list\" class=\"scroll-container\" style=\"max-height: 400px;\">\n          <div class=\"panel-empty\"><span class=\"brand-spinner\"></span> Loading...</div>\n        </div>\n      </div>\n\n      <!-- Networks -->\n      <div id=\"dr-networks\" class=\"panel-section\">\n        <div style=\"display: flex; gap: 8px; margin-bottom: 12px;\">\n          <input type=\"text\" id=\"dr-net-name\" placeholder=\"Network name\" style=\"flex: 1; padding: 6px 10px; border: 1px solid var(--border); border-radius: 6px; background: var(--bg); color: var(--fg);\" />\n          <select id=\"dr-net-driver\" style=\"padding: 6px 10px; border: 1px solid var(--border); border-radius: 6px; background: var(--bg); color: var(--fg);\">\n            <option value=\"bridge\">bridge</option>\n            <option value=\"overlay\">overlay</option>\n            <option value=\"host\">host</option>\n          </select>\n          <button id=\"dr-net-create\" class=\"btn-accent-solid\" style=\"padding: 6px 14px; font-size: 0.82rem;\">Create</button>\n        </div>\n        <div id=\"dr-net-list\" class=\"scroll-container\" style=\"max-height: 400px;\">\n          <div class=\"panel-empty\"><span class=\"brand-spinner\"></span> Loading...</div>\n        </div>\n      </div>\n\n      <!-- Disk Usage -->\n      <div id=\"dr-disk\" class=\"panel-section\">\n        <div id=\"dr-disk-content\">\n          <div class=\"panel-empty\"><span class=\"brand-spinner\"></span> Loading...</div>\n        </div>\n      </div>\n\n      <div class=\"weather-modal-buttons modal-footer-bar\">\n        <button id=\"dr-close\">Close</button>\n      </div>\n    </div>\n  </div>`);\n\n  const modal = document.getElementById('docker-resources-modal');\n  const openBtn = document.getElementById('docker-resources-btn');\n  const closeBtn = document.getElementById('dr-close');\n\n  function fmtBytes(bytes) {\n    if (!bytes || bytes === 0) return '0 B';\n    const units = ['B', 'KB', 'MB', 'GB', 'TB'];\n    const i = Math.floor(Math.log(Math.abs(bytes)) / Math.log(1024));\n    return (bytes / Math.pow(1024, i)).toFixed(1) + ' ' + units[i];\n  }\n\n  // ===== VOLUMES =====\n  async function loadVolumes() {\n    const container = document.getElementById('dr-vol-list');\n    try {\n      const data = await getJSON('/api/v1/docker/volumes');\n      const vols = data.volumes || [];\n      if (vols.length === 0) {\n        container.innerHTML = '<div class=\"panel-empty\"><span class=\"empty-icon\">\uD83D\uDCE6</span>No volumes found.</div>';\n        return;\n      }\n      let html = '<table style=\"width: 100%; border-collapse: collapse; font-size: 0.82rem;\">';\n      html += '<tr style=\"border-bottom: 1px solid var(--border); color: var(--muted);\"><th style=\"padding: 6px; text-align: left;\">Name</th><th style=\"padding: 6px;\">Driver</th><th style=\"padding: 6px;\">Scope</th><th style=\"padding: 6px; text-align: right;\">Actions</th></tr>';\n      for (const v of vols) {\n        const isSystem = v.name === 'buildkit' || v.name.length === 64;\n        html += `<tr style=\"border-bottom: 1px solid var(--border);\">`;\n        html += `<td style=\"padding: 6px; font-weight: 500; max-width: 300px; overflow: hidden; text-overflow: ellipsis; white-space: nowrap;\" title=\"${escapeHtml(v.name)}\">${escapeHtml(v.name.length > 40 ? v.name.substring(0, 37) + '...' : v.name)}</td>`;\n        html += `<td style=\"padding: 6px; text-align: center; color: var(--muted);\">${escapeHtml(v.driver)}</td>`;\n        html += `<td style=\"padding: 6px; text-align: center; color: var(--muted);\">${escapeHtml(v.scope)}</td>`;\n        html += `<td style=\"padding: 6px; text-align: right;\">`;\n        if (!isSystem) {\n          html += `<button class=\"dr-vol-del\" data-name=\"${escapeHtml(v.name)}\" style=\"padding: 3px 8px; font-size: 0.75rem; color: var(--bad-fg);\">Delete</button>`;\n        }\n        html += `</td></tr>`;\n      }\n      html += '</table>';\n      container.innerHTML = html;\n\n      container.querySelectorAll('.dr-vol-del').forEach(btn => {\n        btn.addEventListener('click', async () => {\n          if (!confirm(`Delete volume \"${btn.dataset.name}\"? Data will be lost.`)) return;\n          btn.textContent = '...';\n          btn.disabled = true;\n          try {\n            await deleteAPI(`/api/v1/docker/volumes/${encodeURIComponent(btn.dataset.name)}?force=true`);\n            loadVolumes();\n          } catch (e) {\n            showNotification('Delete failed: ' + e.message, 'error');\n            btn.textContent = 'Delete';\n            btn.disabled = false;\n          }\n        });\n      });\n    } catch (e) {\n      container.innerHTML = `<div class=\"panel-empty\" style=\"color: var(--bad-fg);\">Failed: ${escapeHtml(e.message)}</div>`;\n    }\n  }\n\n  document.getElementById('dr-vol-create')?.addEventListener('click', async () => {\n    const nameInput = document.getElementById('dr-vol-name');\n    const name = nameInput.value.trim();\n    if (!name) { showNotification('Enter a volume name', 'warning'); return; }\n    try {\n      await postJSON('/api/v1/docker/volumes', { name });\n      nameInput.value = '';\n      showNotification(`Volume \"${name}\" created`, 'success');\n      loadVolumes();\n    } catch (e) {\n      showNotification('Create failed: ' + e.message, 'error');\n    }\n  });\n\n  // ===== NETWORKS =====\n  async function loadNetworks() {\n    const container = document.getElementById('dr-net-list');\n    try {\n      const data = await getJSON('/api/v1/docker/networks');\n      const nets = data.networks || [];\n      if (nets.length === 0) {\n        container.innerHTML = '<div class=\"panel-empty\"><span class=\"empty-icon\">\uD83C\uDF10</span>No networks found.</div>';\n        return;\n      }\n      let html = '<table style=\"width: 100%; border-collapse: collapse; font-size: 0.82rem;\">';\n      html += '<tr style=\"border-bottom: 1px solid var(--border); color: var(--muted);\"><th style=\"padding: 6px; text-align: left;\">Name</th><th style=\"padding: 6px;\">Driver</th><th style=\"padding: 6px;\">Scope</th><th style=\"padding: 6px;\">Containers</th><th style=\"padding: 6px; text-align: right;\">Actions</th></tr>';\n      for (const n of nets) {\n        const isSystem = ['bridge', 'host', 'none'].includes(n.name);\n        html += `<tr style=\"border-bottom: 1px solid var(--border);\">`;\n        html += `<td style=\"padding: 6px; font-weight: 500;\">${escapeHtml(n.name)}</td>`;\n        html += `<td style=\"padding: 6px; text-align: center; color: var(--muted);\">${escapeHtml(n.driver)}</td>`;\n        html += `<td style=\"padding: 6px; text-align: center; color: var(--muted);\">${escapeHtml(n.scope)}</td>`;\n        html += `<td style=\"padding: 6px; text-align: center;\">${n.containers}</td>`;\n        html += `<td style=\"padding: 6px; text-align: right;\">`;\n        if (!isSystem) {\n          html += `<button class=\"dr-net-del\" data-id=\"${escapeHtml(n.id)}\" data-name=\"${escapeHtml(n.name)}\" style=\"padding: 3px 8px; font-size: 0.75rem; color: var(--bad-fg);\">Delete</button>`;\n        }\n        html += `</td></tr>`;\n      }\n      html += '</table>';\n      container.innerHTML = html;\n\n      container.querySelectorAll('.dr-net-del').forEach(btn => {\n        btn.addEventListener('click', async () => {\n          if (!confirm(`Delete network \"${btn.dataset.name}\"?`)) return;\n          btn.textContent = '...';\n          btn.disabled = true;\n          try {\n            await deleteAPI(`/api/v1/docker/networks/${encodeURIComponent(btn.dataset.id)}`);\n            loadNetworks();\n          } catch (e) {\n            showNotification('Delete failed: ' + e.message, 'error');\n            btn.textContent = 'Delete';\n            btn.disabled = false;\n          }\n        });\n      });\n    } catch (e) {\n      container.innerHTML = `<div class=\"panel-empty\" style=\"color: var(--bad-fg);\">Failed: ${escapeHtml(e.message)}</div>`;\n    }\n  }\n\n  document.getElementById('dr-net-create')?.addEventListener('click', async () => {\n    const nameInput = document.getElementById('dr-net-name');\n    const driverSelect = document.getElementById('dr-net-driver');\n    const name = nameInput.value.trim();\n    if (!name) { showNotification('Enter a network name', 'warning'); return; }\n    try {\n      await postJSON('/api/v1/docker/networks', { name, driver: driverSelect.value });\n      nameInput.value = '';\n      showNotification(`Network \"${name}\" created`, 'success');\n      loadNetworks();\n    } catch (e) {\n      showNotification('Create failed: ' + e.message, 'error');\n    }\n  });\n\n  // ===== DISK USAGE =====\n  async function loadDiskUsage() {\n    const container = document.getElementById('dr-disk-content');\n    try {\n      const data = await getJSON('/api/v1/docker/disk-usage');\n      const sections = [\n        { label: 'Images', icon: '\uD83D\uDCC0', count: data.images.count, size: data.images.size, reclaimable: data.images.reclaimable },\n        { label: 'Containers', icon: '\uD83D\uDCE6', count: data.containers.count, size: data.containers.size, extra: `${data.containers.running} running` },\n        { label: 'Volumes', icon: '\uD83D\uDCBE', count: data.volumes.count, size: data.volumes.size, reclaimable: data.volumes.reclaimable },\n        { label: 'Build Cache', icon: '\uD83D\uDD27', count: data.buildCache.count, size: data.buildCache.size, reclaimable: data.buildCache.reclaimable },\n      ];\n\n      let html = `<div style=\"font-size: 1.1rem; font-weight: 600; margin-bottom: 16px;\">Total: ${fmtBytes(data.totalSize)}</div>`;\n      html += '<div style=\"display: grid; grid-template-columns: 1fr 1fr; gap: 12px;\">';\n      for (const s of sections) {\n        html += `<div style=\"padding: 14px; background: var(--bg); border-radius: 8px; border: 1px solid var(--border);\">`;\n        html += `<div style=\"font-weight: 600; margin-bottom: 6px;\">${s.icon} ${s.label} <span style=\"color: var(--muted); font-weight: 400; font-size: 0.82rem;\">(${s.count})</span></div>`;\n        html += `<div style=\"font-size: 1.1rem; font-weight: 600; color: var(--accent);\">${fmtBytes(s.size)}</div>`;\n        if (s.reclaimable > 0) html += `<div style=\"font-size: 0.78rem; color: var(--muted);\">Reclaimable: ${fmtBytes(s.reclaimable)}</div>`;\n        if (s.extra) html += `<div style=\"font-size: 0.78rem; color: var(--muted);\">${s.extra}</div>`;\n        html += '</div>';\n      }\n      html += '</div>';\n      container.innerHTML = html;\n    } catch (e) {\n      container.innerHTML = `<div class=\"panel-empty\" style=\"color: var(--bad-fg);\">Failed: ${escapeHtml(e.message)}</div>`;\n    }\n  }\n\n  // Modal events\n  openBtn?.addEventListener('click', () => {\n    modal?.classList.add('show');\n    loadVolumes();\n  });\n  wireModal(modal, closeBtn);\n\n  // Lazy-load tabs\n  document.querySelector('[data-panel=\"dr-networks\"]')?.addEventListener('click', loadNetworks);\n  document.querySelector('[data-panel=\"dr-disk\"]')?.addEventListener('click', loadDiskUsage);\n})();\n;\n// ========== DOCKER COMPOSE IMPORT ==========\n(function() {\n  injectModal('compose-import-modal', `<div id=\"compose-import-modal\" class=\"weather-modal\">\n    <div class=\"weather-modal-content\" style=\"min-width: 650px; max-width: 800px;\">\n      <h3>\uD83D\uDCE6 Import Docker Compose</h3>\n      <p class=\"modal-subtitle\">Paste a docker-compose.yml to import and deploy services.</p>\n\n      <!-- Step 1: Paste YAML -->\n      <div id=\"compose-step-paste\">\n        <div style=\"margin-bottom: 12px;\">\n          <label class=\"form-label-accent-sm\">Stack Name</label>\n          <input type=\"text\" id=\"compose-stack-name\" placeholder=\"my-stack\" value=\"\" style=\"width: 100%; padding: 8px 10px; border: 1px solid var(--border); border-radius: 6px; background: var(--bg); color: var(--fg);\" />\n        </div>\n        <div style=\"margin-bottom: 12px;\">\n          <label class=\"form-label-accent-sm\">docker-compose.yml</label>\n          <textarea id=\"compose-yaml\" rows=\"14\" placeholder=\"version: '3'&#10;services:&#10;  web:&#10;    image: nginx:latest&#10;    ports:&#10;      - '8080:80'\" style=\"width: 100%; padding: 10px; font-family: monospace; font-size: 0.82rem; border: 1px solid var(--border); border-radius: 6px; background: var(--bg); color: var(--fg); resize: vertical;\"></textarea>\n          <div style=\"margin-top: 6px;\">\n            <label style=\"display: inline-flex; align-items: center; gap: 6px; cursor: pointer; font-size: 0.82rem; color: var(--muted);\">\n              <input type=\"file\" id=\"compose-file-upload\" accept=\".yml,.yaml\" style=\"display: none;\" />\n              <span style=\"text-decoration: underline;\">or upload a file</span>\n            </label>\n          </div>\n        </div>\n        <div class=\"weather-modal-buttons modal-footer-bar\">\n          <button id=\"compose-parse-btn\" class=\"btn-accent-solid\" style=\"padding: 8px 20px;\">Parse & Preview</button>\n          <button id=\"compose-cancel\">Cancel</button>\n        </div>\n      </div>\n\n      <!-- Step 2: Preview -->\n      <div id=\"compose-step-preview\" style=\"display: none;\">\n        <div id=\"compose-preview-content\"></div>\n        <div class=\"weather-modal-buttons modal-footer-bar\" style=\"margin-top: 16px;\">\n          <button id=\"compose-deploy-btn\" class=\"btn-accent-solid\" style=\"padding: 8px 20px;\">Deploy All</button>\n          <button id=\"compose-back-btn\">Back</button>\n        </div>\n      </div>\n\n      <!-- Step 3: Progress -->\n      <div id=\"compose-step-progress\" style=\"display: none;\">\n        <div id=\"compose-progress-content\"></div>\n      </div>\n    </div>\n  </div>`);\n\n  const modal = document.getElementById('compose-import-modal');\n  const openBtn = document.getElementById('compose-import-btn');\n  const cancelBtn = document.getElementById('compose-cancel');\n\n  wireModal(modal, cancelBtn);\n\n  let parsedData = null;\n\n  function showStep(step) {\n    document.getElementById('compose-step-paste').style.display = step === 'paste' ? '' : 'none';\n    document.getElementById('compose-step-preview').style.display = step === 'preview' ? '' : 'none';\n    document.getElementById('compose-step-progress').style.display = step === 'progress' ? '' : 'none';\n  }\n\n  openBtn?.addEventListener('click', () => {\n    showStep('paste');\n    parsedData = null;\n    document.getElementById('compose-yaml').value = '';\n    document.getElementById('compose-stack-name').value = '';\n    modal?.classList.add('show');\n  });\n\n  // File upload\n  document.getElementById('compose-file-upload')?.addEventListener('change', (e) => {\n    const file = e.target.files[0];\n    if (!file) return;\n    const reader = new FileReader();\n    reader.onload = () => { document.getElementById('compose-yaml').value = reader.result; };\n    reader.readAsText(file);\n  });\n\n  // Parse\n  document.getElementById('compose-parse-btn')?.addEventListener('click', async () => {\n    const yamlStr = document.getElementById('compose-yaml').value.trim();\n    const stackName = document.getElementById('compose-stack-name').value.trim() || 'stack';\n    if (!yamlStr) { showNotification('Paste a docker-compose.yml', 'warning'); return; }\n\n    const btn = document.getElementById('compose-parse-btn');\n    const origText = btn.textContent;\n    btn.textContent = 'Parsing...';\n    btn.disabled = true;\n\n    try {\n      const data = await postJSON('/api/v1/apps/import-compose', { yaml: yamlStr, stackName });\n      parsedData = data;\n      parsedData.stackName = stackName;\n      renderPreview(data);\n      showStep('preview');\n    } catch (e) {\n      showNotification('Parse failed: ' + e.message, 'error');\n    } finally {\n      btn.textContent = origText;\n      btn.disabled = false;\n    }\n  });\n\n  function renderPreview(data) {\n    const container = document.getElementById('compose-preview-content');\n    let html = '';\n\n    if (data.networks && data.networks.length > 0) {\n      html += `<div style=\"margin-bottom: 12px; font-size: 0.82rem; color: var(--muted);\">Networks: ${data.networks.map(n => `<code>${escapeHtml(n)}</code>`).join(', ')}</div>`;\n    }\n    if (data.volumes && data.volumes.length > 0) {\n      html += `<div style=\"margin-bottom: 12px; font-size: 0.82rem; color: var(--muted);\">Volumes: ${data.volumes.map(v => `<code>${escapeHtml(v)}</code>`).join(', ')}</div>`;\n    }\n\n    html += `<div style=\"font-weight: 600; margin-bottom: 8px;\">${data.services.length} service(s)</div>`;\n    html += '<div class=\"scroll-container\" style=\"max-height: 350px;\">';\n\n    for (const svc of data.services) {\n      const borderColor = svc.skip ? 'var(--bad-fg)' : 'var(--border)';\n      html += `<div style=\"padding: 10px 14px; border: 1px solid ${borderColor}; border-radius: 8px; margin-bottom: 8px; background: var(--bg);\">`;\n      html += `<div style=\"font-weight: 600; font-size: 0.9rem;\">${escapeHtml(svc.name)}`;\n      if (svc.skip) html += ` <span style=\"color: var(--bad-fg); font-weight: 400; font-size: 0.78rem;\">\u2014 skipped: ${escapeHtml(svc.reason)}</span>`;\n      html += `</div>`;\n\n      if (!svc.skip) {\n        html += `<div style=\"font-size: 0.8rem; color: var(--muted); margin-top: 4px;\">Image: <code>${escapeHtml(svc.image)}</code></div>`;\n        if (svc.ports?.length) html += `<div style=\"font-size: 0.8rem; color: var(--muted);\">Ports: ${svc.ports.map(p => `${p.host}:${p.container}`).join(', ')}</div>`;\n        if (svc.volumes?.length) html += `<div style=\"font-size: 0.8rem; color: var(--muted);\">Volumes: ${svc.volumes.length}</div>`;\n        if (Object.keys(svc.environment || {}).length) html += `<div style=\"font-size: 0.8rem; color: var(--muted);\">Env vars: ${Object.keys(svc.environment).length}</div>`;\n        if (svc.envFileWarning) html += `<div style=\"font-size: 0.78rem; color: var(--bad-fg);\">\u26A0 ${escapeHtml(svc.envFileWarning)}</div>`;\n        if (svc.resources?.cpus || svc.resources?.memory) {\n          const parts = [];\n          if (svc.resources.cpus) parts.push(`CPU: ${svc.resources.cpus}`);\n          if (svc.resources.memory) parts.push(`Mem: ${svc.resources.memory}MB`);\n          html += `<div style=\"font-size: 0.8rem; color: var(--muted);\">Limits: ${parts.join(', ')}</div>`;\n        }\n      }\n\n      html += '</div>';\n    }\n    html += '</div>';\n    container.innerHTML = html;\n  }\n\n  // Back button\n  document.getElementById('compose-back-btn')?.addEventListener('click', () => showStep('paste'));\n\n  // Deploy\n  document.getElementById('compose-deploy-btn')?.addEventListener('click', async () => {\n    if (!parsedData) return;\n\n    const btn = document.getElementById('compose-deploy-btn');\n    btn.textContent = 'Deploying...';\n    btn.disabled = true;\n    showStep('progress');\n\n    const progressEl = document.getElementById('compose-progress-content');\n    progressEl.innerHTML = '<div class=\"panel-empty\"><span class=\"brand-spinner\"></span> Deploying services...</div>';\n\n    try {\n      const result = await postJSON('/api/v1/apps/deploy-compose', {\n        services: parsedData.services,\n        networks: parsedData.networks,\n        stackName: parsedData.stackName\n      });\n\n      let html = `<div style=\"font-weight: 600; margin-bottom: 12px;\">Stack \"${escapeHtml(result.stackName)}\" \u2014 Deployment Complete</div>`;\n      html += '<div class=\"scroll-container\" style=\"max-height: 350px;\">';\n\n      for (const r of result.results) {\n        const icon = r.status === 'deployed' || r.status === 'created' ? '\u2705' : r.status === 'exists' ? '\u26A1' : r.status === 'skipped' ? '\u23ED' : '\u274C';\n        html += `<div style=\"padding: 8px 12px; border-bottom: 1px solid var(--border); font-size: 0.85rem;\">`;\n        html += `${icon} <strong>${escapeHtml(r.name)}</strong> (${r.type}) \u2014 ${escapeHtml(r.status)}`;\n        if (r.error) html += ` <span style=\"color: var(--bad-fg);\">${escapeHtml(r.error)}</span>`;\n        if (r.subdomain) html += ` \u2192 <code>${escapeHtml(r.subdomain)}</code>`;\n        if (r.reason) html += ` <span style=\"color: var(--muted);\">(${escapeHtml(r.reason)})</span>`;\n        html += '</div>';\n      }\n      html += '</div>';\n      html += '<div class=\"weather-modal-buttons modal-footer-bar\" style=\"margin-top: 16px;\"><button id=\"compose-done-btn\">Done</button></div>';\n\n      progressEl.innerHTML = html;\n      document.getElementById('compose-done-btn')?.addEventListener('click', () => {\n        modal?.classList.remove('show');\n        if (typeof window.loadServices === 'function') window.loadServices().then(() => { if (typeof window.buildGrid === 'function') window.buildGrid(); });\n      });\n\n      showNotification(`Stack \"${result.stackName}\" deployed`, 'success');\n    } catch (e) {\n      progressEl.innerHTML = `<div class=\"panel-empty\" style=\"color: var(--bad-fg);\">Deployment failed: ${escapeHtml(e.message)}</div>\n        <div class=\"weather-modal-buttons modal-footer-bar\" style=\"margin-top: 16px;\"><button id=\"compose-retry-btn\">Back</button></div>`;\n      document.getElementById('compose-retry-btn')?.addEventListener('click', () => showStep('paste'));\n    } finally {\n      btn.textContent = 'Deploy All';\n      btn.disabled = false;\n    }\n  });\n})();\n;\n// ========== CONTAINER EXEC / SHELL (WebSocket + xterm.js) ==========\n(function() {\n  injectModal('exec-modal', `<div id=\"exec-modal\" class=\"weather-modal\">\n    <div class=\"weather-modal-content\" style=\"min-width: 700px; max-width: 900px; padding-bottom: 0;\">\n      <h3 id=\"exec-title\">Terminal</h3>\n      <div id=\"exec-terminal\" style=\"height: 420px; border-radius: 6px; overflow: hidden; background: #1e1e1e;\"></div>\n      <div class=\"weather-modal-buttons modal-footer-bar\" style=\"margin-top: 8px; padding-bottom: 12px;\">\n        <button id=\"exec-close\">Close</button>\n      </div>\n    </div>\n  </div>`);\n\n  const modal = document.getElementById('exec-modal');\n  const termEl = document.getElementById('exec-terminal');\n  const closeBtn = document.getElementById('exec-close');\n\n  let term = null;\n  let ws = null;\n  let fitAddon = null;\n\n  function cleanup() {\n    if (ws) { try { ws.close(); } catch (_) {} ws = null; }\n    if (term) { try { term.dispose(); } catch (_) {} term = null; }\n    fitAddon = null;\n    termEl.innerHTML = '';\n  }\n\n  function openExec(containerId, containerName) {\n    cleanup();\n\n    document.getElementById('exec-title').textContent = `Terminal \u2014 ${containerName || containerId}`;\n    modal?.classList.add('show');\n\n    // Ensure xterm is available\n    if (typeof Terminal === 'undefined') {\n      termEl.innerHTML = '<div style=\"color: #f44; padding: 20px; font-family: monospace;\">xterm.js not loaded</div>';\n      return;\n    }\n\n    term = new Terminal({\n      cursorBlink: true,\n      fontSize: 14,\n      fontFamily: \"'Cascadia Code', 'Fira Code', 'Consolas', monospace\",\n      theme: {\n        background: '#1e1e1e',\n        foreground: '#d4d4d4',\n        cursor: '#aeafad',\n        selectionBackground: '#264f78',\n      },\n      scrollback: 5000,\n    });\n\n    // Fit addon\n    if (typeof FitAddon !== 'undefined') {\n      fitAddon = new FitAddon.FitAddon();\n      term.loadAddon(fitAddon);\n    }\n\n    term.open(termEl);\n    if (fitAddon) {\n      // Small delay for DOM to settle\n      setTimeout(() => fitAddon.fit(), 50);\n    }\n\n    // Connect WebSocket\n    const protocol = location.protocol === 'https:' ? 'wss:' : 'ws:';\n    ws = new WebSocket(`${protocol}//${location.host}/ws/exec/${encodeURIComponent(containerId)}`);\n    ws.binaryType = 'arraybuffer';\n\n    ws.onopen = () => {\n      term.writeln('\\x1b[32mConnecting...\\x1b[0m');\n      // Send initial resize\n      if (fitAddon) {\n        const dims = fitAddon.proposeDimensions();\n        if (dims) {\n          ws.send(JSON.stringify({ type: 'resize', cols: dims.cols, rows: dims.rows }));\n        }\n      }\n    };\n\n    ws.onmessage = (e) => {\n      if (typeof e.data === 'string') {\n        try {\n          const msg = JSON.parse(e.data);\n          if (msg.type === 'connected') {\n            term.writeln(`\\x1b[32mConnected (${msg.shell})\\x1b[0m\\r\\n`);\n            return;\n          }\n          if (msg.type === 'error') {\n            term.writeln(`\\x1b[31mError: ${msg.message}\\x1b[0m`);\n            return;\n          }\n          if (msg.type === 'exit') {\n            term.writeln('\\r\\n\\x1b[33mSession ended.\\x1b[0m');\n            return;\n          }\n        } catch (_) {}\n        // Plain text\n        term.write(e.data);\n      } else {\n        // Binary data\n        term.write(new Uint8Array(e.data));\n      }\n    };\n\n    ws.onclose = () => {\n      if (term) term.writeln('\\r\\n\\x1b[33mDisconnected.\\x1b[0m');\n    };\n\n    ws.onerror = () => {\n      if (term) term.writeln('\\r\\n\\x1b[31mConnection error.\\x1b[0m');\n    };\n\n    // Terminal input \u2192 WebSocket\n    term.onData((data) => {\n      if (ws && ws.readyState === WebSocket.OPEN) {\n        ws.send(data);\n      }\n    });\n\n    // Handle resize\n    term.onResize(({ cols, rows }) => {\n      if (ws && ws.readyState === WebSocket.OPEN) {\n        ws.send(JSON.stringify({ type: 'resize', cols, rows }));\n      }\n    });\n\n    // Re-fit on window resize\n    const resizeHandler = () => { if (fitAddon) fitAddon.fit(); };\n    window.addEventListener('resize', resizeHandler);\n\n    // Store handler for cleanup\n    modal._resizeHandler = resizeHandler;\n  }\n\n  closeBtn?.addEventListener('click', () => {\n    cleanup();\n    if (modal._resizeHandler) {\n      window.removeEventListener('resize', modal._resizeHandler);\n    }\n    modal?.classList.remove('show');\n  });\n\n  // Also close on backdrop click\n  modal?.addEventListener('click', (e) => {\n    if (e.target === modal) {\n      cleanup();\n      if (modal._resizeHandler) {\n        window.removeEventListener('resize', modal._resizeHandler);\n      }\n      modal?.classList.remove('show');\n    }\n  });\n\n  // Export\n  window.openExecModal = openExec;\n})();\n;\n// ========== AUDIT LOG VIEWER ==========\n// DC-050: surface authenticated user identity (userEmail / userRole from\n// auditLogger.details), add outcome filter, pass confirm=CLEAR body for\n// destructive DELETE.\n(function() {\n  // Inject modal HTML\n  injectModal('audit-modal', `<div id=\"audit-modal\" class=\"weather-modal\">\n    <div class=\"weather-modal-content\" style=\"min-width: 950px; max-width: 1150px;\">\n      <h3>\uD83D\uDCDC Audit Log</h3>\n      <p class=\"modal-subtitle\">\n        Track all actions performed through the API.\n      </p>\n\n      <div style=\"display: flex; gap: 12px; margin-bottom: 12px; align-items: center; flex-wrap: wrap;\">\n        <label class=\"text-muted-sm\">Category:</label>\n        <select id=\"audit-filter\" style=\"padding: 6px 10px; border-radius: 6px; border: 1px solid var(--border); background: var(--bg); color: var(--fg); font-size: 0.85rem;\">\n          <option value=\"\">All</option>\n          <option value=\"service\">Services</option>\n          <option value=\"container\">Containers</option>\n          <option value=\"caddy\">Caddy</option>\n          <option value=\"dns\">DNS</option>\n          <option value=\"backup\">Backups</option>\n          <option value=\"config\">Config</option>\n          <option value=\"auth\">Auth</option>\n        </select>\n        <label class=\"text-muted-sm\">Result:</label>\n        <select id=\"audit-outcome-filter\" style=\"padding: 6px 10px; border-radius: 6px; border: 1px solid var(--border); background: var(--bg); color: var(--fg); font-size: 0.85rem;\">\n          <option value=\"\">Any</option>\n          <option value=\"success\">\u2713 Success</option>\n          <option value=\"failure\">\u2717 Failure</option>\n        </select>\n        <label class=\"text-muted-sm\" style=\"margin-left: 8px;\">Since:</label>\n        <input id=\"audit-since\" type=\"datetime-local\" style=\"padding: 5px 8px; border-radius: 6px; border: 1px solid var(--border); background: var(--bg); color: var(--fg); font-size: 0.82rem;\">\n        <label class=\"text-muted-sm\">Until:</label>\n        <input id=\"audit-until\" type=\"datetime-local\" style=\"padding: 5px 8px; border-radius: 6px; border: 1px solid var(--border); background: var(--bg); color: var(--fg); font-size: 0.82rem;\">\n        <button id=\"audit-refresh-btn\" class=\"btn-sm\">\uD83D\uDD04 Refresh</button>\n        <span style=\"flex: 1;\"></span>\n        <button id=\"audit-clear-btn\" style=\"padding: 6px 12px; font-size: 0.8rem; color: var(--bad-fg); border-color: var(--bad-fg);\">\uD83D\uDDD1\uFE0F Clear Log</button>\n      </div>\n\n      <div id=\"audit-log-container\" class=\"scroll-container\">\n        <div class=\"panel-empty\"><span class=\"brand-spinner\"></span> Loading audit log...</div>\n      </div>\n\n      <div style=\"margin-top: 12px; text-align: center;\">\n        <button id=\"audit-load-more\" style=\"display: none; padding: 6px 16px; font-size: 0.8rem;\">Load More</button>\n      </div>\n\n      <div class=\"weather-modal-buttons modal-footer-bar\">\n        <button id=\"audit-cancel\">Close</button>\n      </div>\n    </div>\n  </div>`);\n\n  const modal = document.getElementById('audit-modal');\n  const openBtn = document.getElementById('audit-log-btn');\n  const cancelBtn = document.getElementById('audit-cancel');\n  const refreshBtn = document.getElementById('audit-refresh-btn');\n  const clearBtn = document.getElementById('audit-clear-btn');\n  const filterSelect = document.getElementById('audit-filter');\n  const outcomeSelect = document.getElementById('audit-outcome-filter');\n  const sinceInput = document.getElementById('audit-since');\n  const untilInput = document.getElementById('audit-until');\n  const container = document.getElementById('audit-log-container');\n  const loadMoreBtn = document.getElementById('audit-load-more');\n  let currentOffset = 0;\n  let inflight = null; // AbortController for the in-flight request\n  let filterNonce = 0; // increments on every fresh (non-append) load; lets\n                       // an in-flight append detect the filter has changed\n                       // and skip its DOM splice.\n  const PAGE_SIZE = 50;\n\n  // datetime-local fields carry no timezone offset \u2014 convert to ISO 8601\n  // with the local offset so the server can compare correctly.\n  function toIso(localDtValue) {\n    if (!localDtValue) return null;\n    // Browsers expose datetime-local as naive local time. new Date() on\n    // that string parses it as LOCAL, so toISOString() yields the UTC\n    // equivalent the server expects.\n    const d = new Date(localDtValue);\n    if (isNaN(d.getTime())) return null;\n    return d.toISOString();\n  }\n\n  async function loadAudit(append) {\n    try {\n      if (!append) {\n        // Cancel any pending request and bump the filter nonce so any\n        // appending fetch (still in flight) knows to discard its response.\n        if (inflight) inflight.abort();\n        inflight = new AbortController();\n        currentOffset = 0;\n        filterNonce++;\n        container.innerHTML = '<div class=\"panel-empty\"><span class=\"brand-spinner\"></span> Loading...</div>';\n      } else {\n        if (inflight) inflight.abort();\n        inflight = new AbortController();\n      }\n      const myNonce = filterNonce;\n      const params = new URLSearchParams();\n      params.set('limit', String(PAGE_SIZE));\n      params.set('offset', String(currentOffset));\n      const action = filterSelect.value;\n      const outcome = outcomeSelect.value;\n      const since = toIso(sinceInput.value);\n      const until = toIso(untilInput.value);\n      if (action) params.set('action', action);\n      if (outcome) params.set('outcome', outcome);\n      if (since) params.set('since', since);\n      if (until) params.set('until', until);\n\n      const res = await fetch('/api/v1/audit-logs?' + params.toString(), {\n        signal: inflight.signal,\n      });\n      // Surface 401/403/500 explicitly \u2014 the dashboard used to render any\n      // non-success response as \"no audit log entries yet,\" which is\n      // misleading for an expired session.\n      if (!res.ok) {\n        container.innerHTML = `<div class=\"panel-empty\" style=\"color: var(--bad-fg);\">Failed: HTTP ${res.status}</div>`;\n        loadMoreBtn.style.display = 'none';\n        return;\n      }\n      const data = await res.json();\n      if (!data.success) {\n        container.innerHTML = `<div class=\"panel-empty\" style=\"color: var(--bad-fg);\">Failed: ${escapeHtml(data.error || 'unknown')}</div>`;\n        loadMoreBtn.style.display = 'none';\n        return;\n      }\n      // If a non-append load happened after this fetch was issued, the\n      // operator changed filters; discard the now-stale response.\n      if (!append && myNonce !== filterNonce) return;\n      const entries = Array.isArray(data.entries) ? data.entries : [];\n\n      if (entries.length === 0 && !append) {\n        const reason = data.filters && (data.filters.action || data.filters.outcome || data.filters.since || data.filters.until)\n          ? 'No entries match your filters.'\n          : 'No audit log entries yet. Actions will be logged automatically.';\n        container.innerHTML = `<div class=\"panel-empty\"><span class=\"empty-icon\">\uD83D\uDCDC</span>${escapeHtml(reason)}</div>`;\n        loadMoreBtn.style.display = 'none';\n        return;\n      }\n\n      let html = '';\n      if (!append) {\n        html = '<table style=\"width: 100%; border-collapse: collapse; font-size: 0.82rem;\">';\n        html += '<tr style=\"border-bottom: 1px solid var(--border); color: var(--muted);\">';\n        html += '<th style=\"padding: 6px; text-align: left;\">When</th>';\n        html += '<th style=\"padding: 6px; text-align: left;\">Actor</th>';\n        html += '<th style=\"padding: 6px; text-align: left;\">IP</th>';\n        html += '<th style=\"padding: 6px; text-align: left;\">Action</th>';\n        html += '<th style=\"padding: 6px; text-align: left;\">Resource</th>';\n        html += '<th style=\"padding: 6px; text-align: left;\">Result</th>';\n        html += '</tr>';\n      }\n\n      for (const e of entries) {\n        const ok = e.outcome === 'success';\n        const actor = actorLabel(e);\n        html += `<tr style=\"border-bottom: 1px solid var(--border); cursor: pointer;\" class=\"audit-row\">`;\n        html += `<td style=\"padding: 6px; color: var(--muted);\" title=\"${escapeHtml(e.timestamp || '')}\">${timeAgo(e.timestamp)}</td>`;\n        html += `<td style=\"padding: 6px; font-size: 0.78rem;\">${actor}</td>`;\n        html += `<td style=\"padding: 6px; font-family: monospace; font-size: 0.78rem;\">${escapeHtml(e.ip || '-')}</td>`;\n        html += `<td style=\"padding: 6px; font-weight: 500;\">${escapeHtml(e.action || '-')}</td>`;\n        html += `<td style=\"padding: 6px;\">${escapeHtml(e.resource || '-')}</td>`;\n        html += `<td style=\"padding: 6px;\"><span style=\"color: ${ok ? 'var(--ok-fg)' : 'var(--bad-fg)'};\">${ok ? '\u2713' : '\u2717'} ${escapeHtml(e.outcome || '')}</span></td>`;\n        html += '</tr>';\n        if (e.details && Object.keys(e.details).length > 0) {\n          html += `<tr class=\"audit-detail\" style=\"display: none;\"><td colspan=\"6\" style=\"padding: 6px 6px 10px; font-size: 0.78rem; color: var(--muted);\"><pre style=\"margin: 0; white-space: pre-wrap; font-family: monospace;\">${escapeHtml(JSON.stringify(e.details, null, 2))}</pre></td></tr>`;\n        }\n      }\n\n      if (!append) {\n        html += '</table>';\n        container.innerHTML = html;\n      } else {\n        const table = container.querySelector('table');\n        if (table) table.insertAdjacentHTML('beforeend', html);\n      }\n\n      currentOffset += entries.length;\n      // hasMore is reported by the server (post-filter total), so the\n      // Load More button stays accurate when filters change mid-scroll.\n      loadMoreBtn.style.display = data.hasMore ? '' : 'none';\n\n      // Toggle detail rows on click\n      container.querySelectorAll('.audit-row').forEach(row => {\n        if (row.dataset.wired) return;\n        row.dataset.wired = 'true';\n        row.addEventListener('click', () => {\n          const detail = row.nextElementSibling;\n          if (detail && detail.classList.contains('audit-detail')) {\n            detail.style.display = detail.style.display === 'none' ? '' : 'none';\n          }\n        });\n      });\n    } catch (e) {\n      // AbortError is expected when we deliberately cancel an in-flight\n      // request (e.g. the operator changed filters mid-fetch) \u2014 don't\n      // flash a \"Failed: The user aborted a request\" message over the\n      // loading spinner. The new fetch has already kicked off.\n      if (e && e.name === 'AbortError') return;\n      container.innerHTML = `<div class=\"panel-empty\" style=\"color: var(--bad-fg);\">Failed: ${escapeHtml(e.message)}</div>`;\n    }\n  }\n\n  // Render the human-readable actor: prefer userEmail, fall back to\n  // userId, fall back to bare IP. If no user attribution, mark as\n  // \"system\" so the operator knows the entry came from an unauthenticated\n  // or service path (e.g. cron-driven backups).\n  function actorLabel(entry) {\n    const d = entry.details || {};\n    const email = d.userEmail;\n    const id = d.userId;\n    const role = d.userRole;\n    const provider = d.viaProvider;\n    if (email) {\n      const tag = role ? ` <span style=\"color: var(--muted); font-size: 0.72rem;\">[${escapeHtml(role)}${provider ? '/' + escapeHtml(provider) : ''}]</span>` : '';\n      return `${escapeHtml(email)}${tag}`;\n    }\n    if (id) return `<span style=\"font-family: monospace; color: var(--muted);\">${escapeHtml(id)}</span>`;\n    if (!entry.ip) return '<span style=\"color: var(--muted);\">system</span>';\n    return '<span style=\"color: var(--muted);\">anon</span>';\n  }\n\n  openBtn?.addEventListener('click', () => {\n    modal?.classList.add('show');\n    loadAudit(false);\n  });\n  wireModal(modal, cancelBtn);\n  refreshBtn?.addEventListener('click', () => loadAudit(false));\n  filterSelect?.addEventListener('change', () => loadAudit(false));\n  outcomeSelect?.addEventListener('change', () => loadAudit(false));\n  // Re-fetch on date change only when both fields have a value or both are\n  // empty \u2014 typing one character shouldn't trigger a fetch for every keystroke.\n  let dateDebounce;\n  [sinceInput, untilInput].forEach((el) => {\n    el?.addEventListener('change', () => {\n      clearTimeout(dateDebounce);\n      dateDebounce = setTimeout(() => loadAudit(false), 250);\n    });\n  });\n  loadMoreBtn?.addEventListener('click', () => loadAudit(true));\n\n  clearBtn?.addEventListener('click', async () => {\n    if (!confirm('Clear the entire audit log? This cannot be undone.')) return;\n    try {\n      const res = await secureFetch('/api/v1/audit-logs', {\n        method: 'DELETE',\n        headers: { 'content-type': 'application/json' },\n        body: JSON.stringify({ confirm: 'CLEAR' }),\n      });\n      const data = await res.json();\n      if (data.success) loadAudit(false);\n      else showNotification('Error: ' + (data.error || 'Clear failed'), 'error');\n    } catch (e) {\n      showNotification('Error: ' + e.message, 'error');\n    }\n  });\n})();;\n// ========== SECURITY CENTER ==========\n// Multi-source security event viewer + host registry UI.\n//\n// Shows live events from any source (API audit, Caddy access log, fail2ban,\n// shared_bans) on any registered host (this DashCaddy, future remote agents).\n//\n// Live-tail uses SSE (/api/v1/security/events/stream).\n(function() {\n  injectModal('security-modal', `<div id=\"security-modal\" class=\"weather-modal\">\n    <div class=\"weather-modal-content\" style=\"min-width: 980px; max-width: 1280px;\">\n      <h3>\uD83D\uDEE1\uFE0F Security Center</h3>\n      <p class=\"modal-subtitle\">\n        Live events from API, Caddy, fail2ban & shared_bans. Live-tail via SSE.\n      </p>\n\n      <div class=\"sec-tabs\" style=\"display:flex;gap:8px;margin-bottom:14px;border-bottom:1px solid var(--border);\">\n        <button class=\"sec-tab active\" data-tab=\"overview\">Overview</button>\n        <button class=\"sec-tab\" data-tab=\"events\">Events</button>\n        <button class=\"sec-tab\" data-tab=\"hosts\">Hosts</button>\n      </div>\n\n      <!-- OVERVIEW TAB -->\n      <div class=\"sec-panel\" data-panel=\"overview\">\n        <div class=\"sec-stats\" id=\"sec-stats\" style=\"display:grid;grid-template-columns:repeat(auto-fit,minmax(180px,1fr));gap:12px;margin-bottom:18px;\">\n          <div class=\"sec-stat\" data-key=\"total\">\u2014 events</div>\n          <div class=\"sec-stat\" data-key=\"warn\">\u2014 warnings</div>\n          <div class=\"sec-stat\" data-key=\"error\">\u2014 errors</div>\n          <div class=\"sec-stat\" data-key=\"denied\">\u2014 denied</div>\n          <div class=\"sec-stat\" data-key=\"hosts\">\u2014 hosts</div>\n        </div>\n        <div style=\"display:grid;grid-template-columns:1fr 1fr;gap:14px;\">\n          <div>\n            <h4 style=\"margin:8px 0 6px;\">Top Actors (24h)</h4>\n            <div id=\"sec-top-actors\" class=\"scroll-container\" style=\"max-height:240px;\">\u2014</div>\n          </div>\n          <div>\n            <h4 style=\"margin:8px 0 6px;\">Top Targets (24h)</h4>\n            <div id=\"sec-top-targets\" class=\"scroll-container\" style=\"max-height:240px;\">\u2014</div>\n          </div>\n        </div>\n      </div>\n\n      <!-- EVENTS TAB -->\n      <div class=\"sec-panel\" data-panel=\"events\" style=\"display:none;\">\n        <div style=\"display:flex;gap:8px;margin-bottom:12px;align-items:center;flex-wrap:wrap;\">\n          <select id=\"sec-filter-source\" class=\"sec-filter\">\n            <option value=\"\">All sources</option>\n            <option value=\"api\">API</option>\n            <option value=\"caddy\">Caddy</option>\n            <option value=\"fail2ban\">fail2ban</option>\n            <option value=\"shared-bans\">shared_bans</option>\n            <option value=\"agent\">Agent</option>\n          </select>\n          <select id=\"sec-filter-severity\" class=\"sec-filter\">\n            <option value=\"\">All severities</option>\n            <option value=\"critical\">critical</option>\n            <option value=\"error\">error</option>\n            <option value=\"warn\">warn</option>\n            <option value=\"notice\">notice</option>\n            <option value=\"info\">info</option>\n          </select>\n          <select id=\"sec-filter-host\" class=\"sec-filter\">\n            <option value=\"\">All hosts</option>\n          </select>\n          <input id=\"sec-filter-actor\" class=\"sec-filter\" placeholder=\"actor (IP or user)\" style=\"padding:6px 10px;\">\n          <button id=\"sec-refresh-btn\" class=\"btn-sm\">\uD83D\uDD04 Refresh</button>\n          <label style=\"margin-left:auto;display:flex;align-items:center;gap:6px;\">\n            <input type=\"checkbox\" id=\"sec-live-tail\" checked>\n            <span>Live tail</span>\n          </label>\n        </div>\n        <div id=\"sec-events-container\" class=\"scroll-container\" style=\"max-height:480px;\">Loading\u2026</div>\n      </div>\n\n      <!-- HOSTS TAB -->\n      <div class=\"sec-panel\" data-panel=\"hosts\" style=\"display:none;\">\n        <div style=\"display:flex;gap:8px;margin-bottom:12px;\">\n          <button id=\"sec-host-register-btn\" class=\"btn-sm\">\u2795 Register Host</button>\n          <button id=\"sec-hosts-refresh\" class=\"btn-sm\">\uD83D\uDD04 Refresh</button>\n        </div>\n        <div id=\"sec-hosts-container\" class=\"scroll-container\" style=\"max-height:480px;\">Loading\u2026</div>\n      </div>\n\n      <div class=\"weather-modal-buttons modal-footer-bar\">\n        <button id=\"sec-cancel\">Close</button>\n      </div>\n    </div>\n  </div>`);\n\n  // ============= STATE =============\n  const modal = document.getElementById('security-modal');\n  const openBtn = document.getElementById('security-center-btn');\n  const cancelBtn = document.getElementById('sec-cancel');\n  const tabs = modal.querySelectorAll('.sec-tab');\n  const panels = modal.querySelectorAll('.sec-panel');\n\n  let allEvents = []; // newest first\n  let allHosts = [];\n  let sseSource = null;\n\n  // ============= TAB SWITCHING =============\n  tabs.forEach(tab => {\n    tab.addEventListener('click', () => {\n      tabs.forEach(t => t.classList.toggle('active', t === tab));\n      panels.forEach(p => p.style.display = p.dataset.panel === tab.dataset.tab ? '' : 'none');\n      if (tab.dataset.tab === 'overview') refreshOverview();\n      if (tab.dataset.tab === 'events') refreshEvents();\n      if (tab.dataset.tab === 'hosts') refreshHosts();\n    });\n  });\n\n  // ============= OPEN/CLOSE =============\n  if (openBtn) {\n    openBtn.addEventListener('click', () => {\n      modal.classList.add('show');\n      refreshOverview();\n      startLiveTail();\n    });\n  }\n  cancelBtn.addEventListener('click', closeModal);\n  modal.addEventListener('click', e => { if (e.target === modal) closeModal(); });\n  function closeModal() {\n    modal.classList.remove('show');\n    stopLiveTail();\n  }\n\n  // ============= LIVE TAIL (SSE) =============\n  function startLiveTail() {\n    stopLiveTail();\n    if (!document.getElementById('sec-live-tail').checked) return;\n    if (typeof EventSource === 'undefined') return; // browser doesn't support\n    try {\n      sseSource = new EventSource('/api/v1/security/events/stream');\n      sseSource.addEventListener('init', (e) => {\n        try {\n          const data = JSON.parse(e.data);\n          allEvents = data.events || [];\n          renderEvents();\n        } catch {}\n      });\n      sseSource.addEventListener('security', (e) => {\n        try {\n          const ev = JSON.parse(e.data);\n          allEvents.unshift(ev);\n          if (allEvents.length > 500) allEvents.length = 500;\n          // Auto-refresh whichever panel is showing\n          const active = modal.querySelector('.sec-tab.active')?.dataset?.tab;\n          if (active === 'events') renderEvents();\n          else if (active === 'overview') refreshOverview();\n        } catch {}\n      });\n      sseSource.onerror = () => { /* browser auto-reconnects */ };\n    } catch (e) {\n      console.warn('[security] SSE failed:', e.message);\n    }\n  }\n  function stopLiveTail() {\n    if (sseSource) { try { sseSource.close(); } catch {} sseSource = null; }\n  }\n  document.getElementById('sec-live-tail').addEventListener('change', () => {\n    if (modal.classList.contains('show')) startLiveTail();\n  });\n\n  // ============= OVERVIEW =============\n  async function refreshOverview() {\n    try {\n      const since = new Date(Date.now() - 24*60*60*1000).toISOString();\n      const [statsRes, hostsRes, eventsRes] = await Promise.all([\n        fetch(`/api/v1/security/events/stats?since=${encodeURIComponent(since)}`),\n        fetch('/api/v1/security/hosts'),\n        fetch(`/api/v1/security/events?limit=1&since=${encodeURIComponent(since)}`),\n      ]);\n      const stats = (await statsRes.json()).data || {};\n      const hosts = (await hostsRes.json()).data?.hosts || [];\n      const eventsCount = (await eventsRes.json()).data?.total || 0;\n\n      document.querySelector('#sec-stats [data-key=\"total\"]').textContent = `${eventsCount} events (24h)`;\n      document.querySelector('#sec-stats [data-key=\"warn\"]').textContent = `${stats.by_severity?.warn || 0} warnings`;\n      document.querySelector('#sec-stats [data-key=\"error\"]').textContent = `${stats.by_severity?.error || 0} errors`;\n      document.querySelector('#sec-stats [data-key=\"denied\"]').textContent = `${stats.by_outcome?.denied || 0} denied`;\n      document.querySelector('#sec-stats [data-key=\"hosts\"]').textContent = `${hosts.length} hosts`;\n\n      renderTopList('sec-top-actors', stats.top_actors || []);\n      renderTopList('sec-top-targets', stats.top_targets || []);\n    } catch (e) {\n      console.warn('[security] refreshOverview failed:', e.message);\n    }\n  }\n  function renderTopList(id, items) {\n    const el = document.getElementById(id);\n    if (!items.length) { el.innerHTML = '<div class=\"panel-empty\">No data</div>'; return; }\n    el.innerHTML = '<table style=\"width:100%;font-size:0.85rem;\">' +\n      items.map(it => `<tr><td style=\"padding:3px 0;word-break:break-all;\">${escapeHtml(String(it.key))}</td><td style=\"text-align:right;color:var(--muted);\">${it.count}</td></tr>`).join('') +\n      '</table>';\n  }\n\n  // ============= EVENTS =============\n  const filterSource = document.getElementById('sec-filter-source');\n  const filterSeverity = document.getElementById('sec-filter-severity');\n  const filterHost = document.getElementById('sec-filter-host');\n  const filterActor = document.getElementById('sec-filter-actor');\n  const refreshBtn = document.getElementById('sec-refresh-btn');\n\n  [filterSource, filterSeverity, filterHost].forEach(el => el.addEventListener('change', refreshEvents));\n  filterActor.addEventListener('input', debounce(refreshEvents, 250));\n  refreshBtn.addEventListener('click', refreshEvents);\n\n  async function refreshEvents() {\n    try {\n      const params = new URLSearchParams();\n      params.set('limit', '200');\n      if (filterSource.value)  params.set('source_type', filterSource.value);\n      if (filterSeverity.value) params.set('severity', filterSeverity.value);\n      if (filterHost.value)    params.set('source_host', filterHost.value);\n      if (filterActor.value)   params.set('actor_prefix', filterActor.value);\n\n      const res = await fetch(`/api/v1/security/events?${params}`);\n      const data = (await res.json()).data;\n      allEvents = data.events || [];\n      renderEvents();\n\n      // Refresh host dropdown if we don't have it yet\n      if (!filterHost.options.length || filterHost.options.length === 1) {\n        await refreshHostFilter();\n      }\n    } catch (e) {\n      document.getElementById('sec-events-container').innerHTML = '<div class=\"panel-empty\">Load failed: '+escapeHtml(e.message)+'</div>';\n    }\n  }\n\n  function renderEvents() {\n    const el = document.getElementById('sec-events-container');\n    if (!allEvents.length) { el.innerHTML = '<div class=\"panel-empty\">No events</div>'; return; }\n    el.innerHTML = allEvents.slice(0, 200).map(renderEventRow).join('');\n  }\n\n  function renderEventRow(ev) {\n    const sev = ev.severity || 'info';\n    const sevColor = {\n      critical: '#c0392b', error: '#e74c3c', warn: '#f39c12',\n      notice: '#3498db', info: '#7f8c8d',\n    }[sev] || '#7f8c8d';\n    const time = ev.ts ? new Date(ev.ts).toLocaleTimeString() : '';\n    const source = ev.source_type || '';\n    const actor = ev.actor || '\u2014';\n    const target = ev.target || '';\n    const action = ev.action || '';\n    const outcome = ev.outcome || '';\n    return `<div class=\"sec-event-row\" style=\"display:grid;grid-template-columns:84px 80px 1fr 1fr 100px 90px;gap:8px;padding:5px 8px;border-bottom:1px solid var(--border);font-size:0.82rem;align-items:center;\">\n      <span style=\"color:${sevColor};font-weight:600;\">${escapeHtml(sev)}</span>\n      <span style=\"color:var(--muted);font-size:0.75rem;\">${escapeHtml(source)}</span>\n      <span title=\"${escapeHtml(actor)}\" style=\"overflow:hidden;text-overflow:ellipsis;white-space:nowrap;\">${escapeHtml(actor)}</span>\n      <span title=\"${escapeHtml(target)}\" style=\"overflow:hidden;text-overflow:ellipsis;white-space:nowrap;\">${escapeHtml(action)} ${escapeHtml(target)}</span>\n      <span style=\"color:var(--muted);font-size:0.75rem;\">${escapeHtml(outcome)}</span>\n      <span style=\"color:var(--muted);font-size:0.75rem;text-align:right;\">${escapeHtml(time)}</span>\n    </div>`;\n  }\n\n  async function refreshHostFilter() {\n    try {\n      const res = await fetch('/api/v1/security/hosts');\n      const hosts = (await res.json()).data?.hosts || [];\n      const current = filterHost.value;\n      filterHost.innerHTML = '<option value=\"\">All hosts</option>' +\n        hosts.map(h => `<option value=\"${escapeHtml(h.id)}\">${escapeHtml(h.label || h.id)}</option>`).join('');\n      if (current) filterHost.value = current;\n    } catch {}\n  }\n\n  // ============= HOSTS =============\n  document.getElementById('sec-host-register-btn').addEventListener('click', registerHostPrompt);\n  document.getElementById('sec-hosts-refresh').addEventListener('click', refreshHosts);\n\n  async function refreshHosts() {\n    try {\n      const res = await fetch('/api/v1/security/hosts');\n      const hosts = (await res.json()).data?.hosts || [];\n      allHosts = hosts;\n      const el = document.getElementById('sec-hosts-container');\n      if (!hosts.length) { el.innerHTML = '<div class=\"panel-empty\">No hosts registered. Click \u2795 Register Host to add one.</div>'; return; }\n      el.innerHTML = hosts.map(h => {\n        const status = !h.enabled ? '\uD83D\uDD34 disabled'\n                     : !h.last_seen_at ? '\u26AA registered'\n                     : (Date.now() - Date.parse(h.last_seen_at) > 30*60*1000) ? '\uD83D\uDFE1 stale'\n                     : '\uD83D\uDFE2 online';\n        return `<div style=\"padding:10px 12px;border-bottom:1px solid var(--border);display:flex;justify-content:space-between;align-items:center;\">\n          <div>\n            <strong>${escapeHtml(h.label || h.id)}</strong>\n            <span style=\"color:var(--muted);margin-left:8px;font-size:0.8rem;\">${escapeHtml(h.type)}</span>\n            <div style=\"color:var(--muted);font-size:0.78rem;margin-top:2px;\">\n              id: ${escapeHtml(h.id)} \u00B7\n              registered ${new Date(h.registered_at).toLocaleDateString()} \u00B7\n              last seen ${h.last_seen_at ? new Date(h.last_seen_at).toLocaleString() : 'never'}\n            </div>\n          </div>\n          <div>\n            <span style=\"font-size:0.85rem;margin-right:12px;\">${status}</span>\n            ${h.id === 'self' ? '' : `<button class=\"btn-sm sec-host-del\" data-id=\"${escapeHtml(h.id)}\" style=\"color:var(--bad-fg);\">Remove</button>`}\n          </div>\n        </div>`;\n      }).join('');\n\n      el.querySelectorAll('.sec-host-del').forEach(btn => {\n        btn.addEventListener('click', async () => {\n          if (!confirm(`Remove host ${btn.dataset.id}? Events already received will remain in the store.`)) return;\n          await fetch(`/api/v1/security/hosts/${encodeURIComponent(btn.dataset.id)}`, { method: 'DELETE' });\n          refreshHosts();\n        });\n      });\n    } catch (e) {\n      document.getElementById('sec-hosts-container').innerHTML = '<div class=\"panel-empty\">Load failed: '+escapeHtml(e.message)+'</div>';\n    }\n  }\n\n  async function registerHostPrompt() {\n    const id = prompt('Host id (lowercase, no spaces):');\n    if (!id) return;\n    const label = prompt('Display label:', id) || id;\n    const type  = prompt('Type (\"dashcaddy\", \"service\", or \"agent\"):', 'agent') || 'agent';\n    try {\n      const res = await fetch('/api/v1/security/hosts', {\n        method: 'POST',\n        headers: { 'Content-Type': 'application/json' },\n        body: JSON.stringify({ id, label, type }),\n      });\n      const data = await res.json();\n      if (!res.ok) { alert('Failed: ' + (data?.error?.message || res.statusText)); return; }\n      // Show the api_key ONCE in a dialog\n      alert(`\u2705 Host registered!\\n\\nid: ${data.data.host.id}\\nlabel: ${data.data.host.label}\\ntype: ${data.data.host.type}\\n\\n\uD83D\uDD11 API KEY (save this NOW \u2014 won't be shown again):\\n\\n${data.data.api_key}\\n\\nSend this key as: Authorization: Bearer <api_key>\\nTo endpoint: POST /api/v1/security/events/ingest or /events/batch`);\n      refreshHosts();\n    } catch (e) {\n      alert('Failed: ' + e.message);\n    }\n  }\n\n  // ============= HELPERS =============\n  function escapeHtml(s) {\n    return String(s).replace(/[&<>\"']/g, c => ({'&':'&amp;','<':'&lt;','>':'&gt;','\"':'&quot;',\"'\":'&#39;'}[c]));\n  }\n  function debounce(fn, ms) {\n    let t; return function() { clearTimeout(t); t = setTimeout(() => fn.apply(this, arguments), ms); };\n  }\n})();;\n// ========== SHIPDECK DEPLOYS (DC-130) ==========\n// Source deploys panel: drives the shipdeck CLI via the DashCaddy\n// /api/v1/deploys bridge proxy. Modal lists deployable repos + deployed\n// services, shows the journal, and runs deploy/rollback with live output.\n//\n// Follows the security-center.js modal pattern (injectModal + button in the\n// top bar) and the weather-modal visual language.\n\n// DC-133: pure repo-option builder. Remote Gitea fields are UNTRUSTED (a\n// hostile instance controls full_name/description/url), so every\n// interpolated value must be HTML-escaped before innerHTML. Exposed on\n// window so status/tests can pin the escaping with hostile payloads.\nwindow.__dc133_buildRepoOptions = function (repos, escFn) {\n  var e = escFn || function (s) {\n    return String(s).replace(/[&<>\"']/g, function (c) {\n      return { '&': '&amp;', '<': '&lt;', '>': '&gt;', '\"': '&quot;', \"'\": '&#39;' }[c];\n    });\n  };\n  return '<option value=\"\">\u2014 choose a repo \u2014</option>' +\n    (repos || []).map(function (r) {\n      return '<option value=\"' + e(r.url) + '\" data-id=\"' + e(r.id) + '\">' +\n        e(r.full_name) + (r.description ? ' \u2014 ' + e(r.description) : '') + '</option>';\n    }).join('');\n};\n\n// Three-state token semantics, exposed for VM tests:\n// anonymous=true -> explicit empty; typed value -> token; neither -> omitted.\nwindow.__dc133_requestToken = function (anonymous, typed) {\n  if (anonymous) return '';\n  var t = String(typed || '').trim();\n  return t || undefined;\n};\n\n(function () {\n  injectModal('deploys-modal', `<div id=\"deploys-modal\" class=\"weather-modal\">\n    <div class=\"weather-modal-content\" style=\"min-width: 860px; max-width: 1200px;\">\n      <h3>\uD83D\uDE9A Deploys</h3>\n      <p class=\"modal-subtitle\">\n        Source deploys via shipdeck: build \u2192 package \u2192 systemd release \u2192 Caddy gate \u2192 DNS \u2192 verify.\n      </p>\n\n      <div class=\"sec-tabs\" style=\"display:flex;gap:8px;margin-bottom:14px;border-bottom:1px solid var(--border);\">\n        <button class=\"dep-tab active\" data-tab=\"services\">Services</button>\n        <button class=\"dep-tab\" data-tab=\"deploy\">Deploy</button>\n        <button class=\"dep-tab\" data-tab=\"journal\">Journal</button><button class=\"dep-tab\" data-tab=\"install\">Install</button>\n      </div>\n\n      <!-- SERVICES TAB -->\n      <div class=\"dep-panel\" data-panel=\"services\">\n        <div id=\"dep-services\" class=\"scroll-container\" style=\"max-height:320px;\">Loading\u2026</div>\n        <div style=\"margin-top:10px;display:flex;gap:8px;align-items:center;\">\n          <input id=\"dep-status-name\" placeholder=\"service name\" style=\"width:220px;\" />\n          <button class=\"btn\" id=\"dep-status-btn\">Check status</button>\n        </div>\n      </div>\n\n      <!-- DEPLOY TAB -->\n      <div class=\"dep-panel\" data-panel=\"deploy\" style=\"display:none;\">\n        <div style=\"display:flex;gap:8px;align-items:center;margin-bottom:10px;\">\n          <select id=\"dep-repo-select\" style=\"min-width:280px;\"><option>Loading\u2026</option></select>\n          <button class=\"btn btn-primary\" id=\"dep-deploy-btn\">Deploy</button>\n        </div>\n        <p class=\"modal-subtitle\">Deploys are serialized fleet-side; a run takes ~30-60s. Output streams below when it finishes.</p>\n      </div>\n\n      <!-- JOURNAL TAB -->\n      <div class=\"dep-panel\" data-panel=\"journal\" style=\"display:none;\">\n        <div style=\"display:flex;gap:8px;align-items:center;margin-bottom:10px;\">\n          <input id=\"dep-journal-name\" placeholder=\"service (empty = all)\" style=\"width:220px;\" />\n          <button class=\"btn\" id=\"dep-journal-btn\">Refresh</button>\n        </div>\n        <div id=\"dep-journal\" class=\"scroll-container\" style=\"max-height:320px;\">Loading\u2026</div>\n      </div>\n\n      <!-- INSTALL TAB (DC-131) -->\n      <div class=\"dep-panel\" data-panel=\"install\" style=\"display:none;\">\n        <div style=\"display:grid;gap:10px;max-width:640px;\">\n          <div style=\"display:grid;gap:4px;\">\n            <span class=\"modal-subtitle\" style=\"margin:0;\">Gitea server (any instance)</span>\n            <div style=\"display:flex;gap:8px;\">\n              <input id=\"dep-gh-gitea-host\" placeholder=\"git.dashcaddy.net (default)\" style=\"flex:1;\" autocomplete=\"off\" spellcheck=\"false\" />\n              <input id=\"dep-gh-gitea-token\" type=\"password\" placeholder=\"token (private repos)\" style=\"flex:1;\" autocomplete=\"off\" spellcheck=\"false\" />\n            </div>\n            <label style=\"display:flex;gap:6px;align-items:center;font-size:12px;\">\n              <input id=\"dep-gh-anonymous\" type=\"checkbox\" />\n              Anonymous \u2014 ignore the saved fleet token for this request\n            </label>\n          </div>\n          <label style=\"display:grid;gap:4px;\">\n            <span class=\"modal-subtitle\" style=\"margin:0;\">Pick a repo</span>\n            <select id=\"dep-gh-gitea\" style=\"min-width:280px;\"><option value=\"\">Loading\u2026</option></select>\n          </label>\n          <label style=\"display:grid;gap:4px;\">\n            <span class=\"modal-subtitle\" style=\"margin:0;\">\u2026or paste any repo URL (GitHub, Gitea, or any https git host)</span>\n            <input id=\"dep-gh-url\" placeholder=\"https://host/owner/repo\" style=\"width:100%;\" />\n          </label>\n          <label style=\"display:grid;gap:4px;\">\n            <span class=\"modal-subtitle\" style=\"margin:0;\">Name (used as subdomain; card title falls back to repo name)</span>\n            <input id=\"dep-gh-service\" placeholder=\"my-app\" style=\"width:220px;\" />\n          </label>\n          <label style=\"display:grid;gap:4px;\">\n            <span class=\"modal-subtitle\" style=\"margin:0;\">Optional launch args (space-separated simple tokens, e.g. -text hi)</span>\n            <input id=\"dep-gh-args\" placeholder=\"-text hello\" style=\"width:100%;\" />\n          </label>\n          <p class=\"modal-subtitle\" style=\"margin:0;\">\n            Go repos with a main package install automatically: build, systemd release,\n            Caddy gate (tailnet-only), DNS, verify, dashboard card. Takes ~30-60s.\n          </p>\n          <div><button class=\"btn btn-primary\" id=\"dep-gh-btn\">Install</button></div>\n        </div>\n      </div>\n      <!-- OUTPUT -->\n      <pre id=\"dep-output\" class=\"scroll-container\" style=\"display:none;max-height:260px;margin-top:12px;background:var(--bg-2,#111);padding:10px;border-radius:8px;white-space:pre-wrap;\"></pre>\n\n      <div style=\"display:flex;justify-content:flex-end;gap:8px;margin-top:14px;\">\n        <button class=\"btn\" id=\"dep-close\">Close</button>\n      </div>\n    </div>\n  </div>`);\n\n  const $ = (id) => document.getElementById(id);\n  let openBtn = null;\n  let loadedOnce = false;\n\n  function esc(s) {\n    return window.escapeHtml ? window.escapeHtml(String(s)) : String(s).replace(/[&<>\"']/g, (c) => ({'&':'&amp;','<':'&lt;','>':'&gt;','\"':'&quot;',\"'\":'&#39;'}[c]));\n  }\n\n  async function api(path, opts) {\n    const r = await fetch('/dashcaddy-api/api/v1/deploys' + path, Object.assign({ credentials: 'include' }, opts || {}));\n    let body = null;\n    try { body = await r.json(); } catch (e) { body = { success: false, error: 'non-JSON response' }; }\n    return { status: r.status, body };\n  }\n\n  function showOutput(text) {\n    const el = $('dep-output');\n    el.style.display = 'block';\n    el.textContent = text || '(no output)';\n    el.scrollTop = el.scrollHeight;\n  }\n\n  async function loadServices() {\n    const el = $('dep-services');\n    const { body } = await api('/services');\n    if (!body.success) {\n      el.innerHTML = '<em>' + esc(body.error || 'unavailable') + '</em>';\n      return;\n    }\n    const rows = body.services || [];\n    if (!rows.length) {\n      el.innerHTML = '<em>No shipdeck deployments on record yet.</em>';\n      return;\n    }\n    el.innerHTML = '<table class=\"table\" style=\"width:100%;\"><thead><tr>' +\n      '<th>Service</th><th>Last action</th><th>When</th><th>Release</th><th></th>' +\n      '</tr></thead><tbody>' +\n      rows.map((s) =>\n        '<tr>' +\n        '<td><strong>' + esc(s.name) + '</strong></td>' +\n        '<td>' + esc(s.last_action) + '</td>' +\n        '<td>' + esc(s.last_time) + '</td>' +\n        '<td>' + esc(s.last_epoch) + '</td>' +\n        '<td><button class=\"btn btn-sm dep-rollback\" data-service=\"' + esc(s.name) + '\">Rollback</button> ' +\n        '<button class=\"btn btn-sm dep-status\" data-service=\"' + esc(s.name) + '\">Status</button></td>' +\n        '</tr>'\n      ).join('') + '</tbody></table>';\n  }\n\n  async function loadRepos() {\n    const sel = $('dep-repo-select');\n    const { body } = await api('/repos');\n    if (!body.success) {\n      sel.innerHTML = '<option>' + esc(body.error || 'unavailable') + '</option>';\n      return;\n    }\n    const repos = body.repos || [];\n    sel.innerHTML = repos.length\n      ? repos.map((r) => '<option value=\"' + esc(r.dir) + '\">' + esc(r.name) + '</option>').join('')\n      : '<option value=\"\">(no repos with a Shipdeckfile found)</option>';\n  }\n\n  async function loadJournal(service) {\n    const el = $('dep-journal');\n    const qs = service ? '?service=' + encodeURIComponent(service) : '';\n    const { body } = await api('/journal' + qs);\n    const rows = (body.rows || []);\n    if (!rows.length) {\n      el.innerHTML = '<em>No journal rows.</em>';\n      return;\n    }\n    el.innerHTML = '<table class=\"table\" style=\"width:100%;\"><thead><tr>' +\n      '<th>Time</th><th>Service</th><th>Action</th><th>Release</th><th>Duration</th>' +\n      '</tr></thead><tbody>' +\n      rows.map((r) =>\n        '<tr><td>' + esc(r.time) + '</td><td>' + esc(r.service) + '</td><td>' + esc(r.action) +\n        '</td><td>' + esc(r.epoch) + '</td><td>' + esc(r.duration || '\u2014') + '</td></tr>'\n      ).join('') + '</tbody></table>';\n  }\n\n\n\n  async function loadGiteaRepos() {\n    const sel = document.getElementById('dep-gh-gitea');\n    const hostEl = document.getElementById('dep-gh-gitea-host');\n    const tokEl = document.getElementById('dep-gh-gitea-token');\n    const anonEl = document.getElementById('dep-gh-anonymous');\n    const payload = {};\n    if (hostEl && hostEl.value.trim()) payload.gitea_url = 'https://' + hostEl.value.trim().replace(/^https?:\\/*/, '');\n    // Distinguish omitted (fleet fallback allowed) from explicit anonymous\n    // (empty token preserved on wire). A non-empty user token wins.\n    if (anonEl && anonEl.checked) payload.token = '';\n    else {\n      const t = window.__dc133_requestToken(false, tokEl && tokEl.value);\n      if (t !== undefined) payload.token = t;\n    }\n    try {\n      const { status, body } = await api('/gitea-repos', {\n        method: 'POST',\n        headers: { 'Content-Type': 'application/json' },\n        body: JSON.stringify(payload),\n      });\n      if (!body.success || !(body.repos || []).length) {\n        sel.innerHTML = '<option value=\"\">' + esc(body.error || 'no repos found') + '</option>';\n        return;\n      }\n      // All remote fields are untrusted (hostile Gitea instance or repo\n      // metadata) \u2014 build options through the escaping helper (pinned by\n      // status/tests/deploys-install.test.js).\n      sel.innerHTML = window.__dc133_buildRepoOptions(body.repos, esc);\n    } catch (e) {\n      sel.innerHTML = '<option value=\"\">unavailable</option>';\n    }\n  }\n\n  async function runInstall() {\n    const btn = document.getElementById('dep-gh-btn');\n    const repoUrl = document.getElementById('dep-gh-url').value.trim();\n    const service = (document.getElementById('dep-gh-service').value.trim() || '').toLowerCase();\n    const argsRaw = document.getElementById('dep-gh-args').value.trim();\n    if (!repoUrl || !service) { showOutput('Repo URL and name are required.'); return; }\n    const args = argsRaw ? argsRaw.split(/\\s+/) : [];\n    setBusy(true, btn, 'Install');\n    showOutput('Installing ' + repoUrl + '\\nCloning, building, gating and DNS-ing... (~30-60s)');\n    try {\n      const anonymous = !!(document.getElementById('dep-gh-anonymous') || {}).checked;\n      const typedToken = (document.getElementById('dep-gh-gitea-token') || { value: '' }).value;\n      const requestToken = window.__dc133_requestToken(anonymous, typedToken);\n      const { status, body } = await api('/install', {\n        method: 'POST',\n        headers: { 'Content-Type': 'application/json' },\n        body: JSON.stringify({ repo_url: repoUrl, service, args,\n          token: requestToken }),\n      });\n      if (!body.success) {\n        showOutput((body.output ? body.output + '\\n' : '') + 'FAIL ' + (body.error || ('HTTP ' + status)));\n        setBusy(false, btn, 'Install');\n        return;\n      }\n      const svc = body.service || {};\n      const exists = (window.APPS || []).some((a) => a.id === svc.id);\n      if (!exists) {\n        const card = { id: svc.id, name: svc.name || svc.id, url: svc.url, logo: svc.logo, tailscaleOnly: true, isCustom: true };\n        try {\n          await fetch('/dashcaddy-api/api/v1/services', {\n            method: 'POST',\n            credentials: 'include',\n            headers: { 'Content-Type': 'application/json' },\n            body: JSON.stringify(card),\n          });\n          window.APPS.push(card);\n          if (typeof window.renderApps === 'function') window.renderApps();\n          if (typeof window.renderGrid === 'function') window.renderGrid();\n        } catch (e) { /* card registration best-effort */ }\n      }\n      showOutput('INSTALLED ' + (svc.name || svc.id) + ' in ' + (svc.deploy_seconds || '?') + 's' +\n        '\\nCard: ' + (svc.url || '') +\n        '\\n' + (body.output || '').slice(-800));\n      loadServices();\n    } catch (e) {\n      showOutput('install error: ' + e.message);\n    }\n    setBusy(false, btn, 'Install');\n  }\n\n  function setBusy(busy, btn, label) {\n    if (!btn) return;\n    btn.disabled = busy;\n    if (label) btn.textContent = busy ? 'Working\u2026' : label;\n  }\n\n  async function runDeploy() {\n    const btn = $('dep-deploy-btn');\n    const dir = $('dep-repo-select').value;\n    if (!dir) return;\n    setBusy(true, btn, 'Deploy');\n    showOutput('Deploying ' + dir + '\\nThis can take ~30-60s\u2026');\n    try {\n      const { body } = await api('/deploy', {\n        method: 'POST',\n        headers: { 'Content-Type': 'application/json' },\n        body: JSON.stringify({ dir }),\n      });\n      showOutput((body.output || body.error || '') + (body.success ? '\\n\u2705 SUCCESS' : '\\n\u274C FAILED'));\n      loadServices();\n    } catch (e) {\n      showOutput('deploy error: ' + e.message);\n    }\n    setBusy(false, btn, 'Deploy');\n  }\n\n  async function runRollback(service, btn) {\n    if (!confirm('Roll back ' + service + ' to the previous release?')) return;\n    setBusy(true, btn, 'Rollback');\n    showOutput('Rolling back ' + service + '\u2026');\n    try {\n      const { body } = await api('/rollback', {\n        method: 'POST',\n        headers: { 'Content-Type': 'application/json' },\n        body: JSON.stringify({ service }),\n      });\n      showOutput((body.output || body.error || '') + (body.success ? '\\n\u2705 ROLLED BACK' : '\\n\u274C FAILED'));\n      loadServices();\n    } catch (e) {\n      showOutput('rollback error: ' + e.message);\n    }\n    setBusy(false, btn, 'Rollback');\n  }\n\n  async function runStatus(service, btn) {\n    setBusy(true, btn, 'Status');\n    try {\n      const { body } = await api('/status?service=' + encodeURIComponent(service));\n      showOutput(body.output || body.error || '(no output)');\n    } catch (e) {\n      showOutput('status error: ' + e.message);\n    }\n    setBusy(false, btn, 'Status');\n  }\n\n  function wire() {\n    openBtn = document.getElementById('deploys-btn');\n    if (!openBtn) return;\n\n    openBtn.addEventListener('click', async () => {\n      $('deploys-modal').classList.add('open');\n      if (!loadedOnce) {\n        loadedOnce = true;\n        loadServices();\n        loadRepos();\n        loadJournal('');\n        loadGiteaRepos();\n      }\n    });\n\n    $('dep-close').addEventListener('click', () => {\n      $('deploys-modal').classList.remove('open');\n    });\n\n    // tab switching\n    document.querySelectorAll('.dep-tab').forEach((tab) => {\n      tab.addEventListener('click', () => {\n        document.querySelectorAll('.dep-tab').forEach((t) => t.classList.remove('active'));\n        tab.classList.add('active');\n        document.querySelectorAll('#deploys-modal .dep-panel').forEach((p) => {\n          p.style.display = p.dataset.panel === tab.dataset.tab ? 'block' : 'none';\n        });\n      });\n    });\n\n    $('dep-deploy-btn').addEventListener('click', runDeploy);\n    $('dep-gh-btn').addEventListener('click', runInstall);\n    ['dep-gh-gitea-host', 'dep-gh-gitea-token'].forEach((id) => {\n      const el = document.getElementById(id);\n      if (el) el.addEventListener('change', () => loadGiteaRepos());\n    });\n    document.getElementById('dep-gh-gitea').addEventListener('change', (e) => {\n      const v = e.target.value;\n      if (v) {\n        document.getElementById('dep-gh-url').value = v;\n        const opt = e.target.selectedOptions[0];\n        const id = opt && opt.dataset ? opt.dataset.id : '';\n        const svc = document.getElementById('dep-gh-service');\n        if (id && !svc.value) svc.value = id;\n      }\n    });\n\n\n    $('dep-journal-btn').addEventListener('click', () => loadJournal($('dep-journal-name').value.trim()));\n    $('dep-status-btn').addEventListener('click', () => {\n      const name = $('dep-status-name').value.trim();\n      if (name) runStatus(name);\n    });\n\n    // dynamic buttons (service table)\n    $('dep-services').addEventListener('click', (e) => {\n      const rb = e.target.closest('.dep-rollback');\n      if (rb) return runRollback(rb.dataset.service, rb);\n      const sb = e.target.closest('.dep-status');\n      if (sb) return runStatus(sb.dataset.service, sb);\n    });\n  }\n\n  if (document.readyState === 'loading') {\n    document.addEventListener('DOMContentLoaded', wire);\n  } else {\n    wire();\n  }\n})();\n;\n// ========== WEATHER WIDGET ==========\n(function() {\n  const errorHandler = new ErrorHandler();\n  // Inject modal HTML\n  injectModal('weather-modal', `<div id=\"weather-modal\" class=\"weather-modal\"><div class=\"weather-modal-content\"><h3>Weather Settings</h3>\n    <label for=\"weather-location-input\">Location:</label>\n    <input type=\"text\" id=\"weather-location-input\" placeholder=\"City name or ZIP (e.g., Hamburg, 90210)\" maxlength=\"100\">\n    <div style=\"font-size: 0.78rem; color: var(--muted); margin-top: 4px;\">Enter a city name, postal code, or &ldquo;City, Country&rdquo;</div>\n    <div style=\"margin-top: 14px; padding-top: 12px; border-top: 1px solid var(--border);\">\n      <label style=\"display: block; margin-bottom: 8px; font-weight: 600; color: var(--fg);\">Units</label>\n      <div style=\"display: flex; gap: 8px;\">\n        <label class=\"weather-unit-option\"><input type=\"radio\" name=\"weather-unit-radio\" value=\"imperial\"><span class=\"weather-unit-card\">&deg;F / mph</span></label>\n        <label class=\"weather-unit-option\"><input type=\"radio\" name=\"weather-unit-radio\" value=\"metric\"><span class=\"weather-unit-card\">&deg;C / km/h</span></label>\n      </div>\n    </div>\n    <div class=\"weather-modal-buttons\"><button id=\"weather-cancel\">Cancel</button><button id=\"weather-save\">Save</button></div></div></div>`);\n\n  /* Weather Widget \u2014 powered by Open-Meteo (free, no API key) */\n  const LOCATION_KEY = 'weather-location';\n  const LEGACY_KEY = 'weather-zip';\n  const GEO_CACHE_KEY = 'weather-geo';\n  const UNIT_KEY = 'weather-unit';\n\n  // Migrate from old ZIP-only key\n  if (!safeGet(LOCATION_KEY) && safeGet(LEGACY_KEY)) {\n    safeSet(LOCATION_KEY, safeGet(LEGACY_KEY));\n  }\n\n  function getUnit() {\n    return safeGet(UNIT_KEY) || 'imperial';\n  }\n\n  function getWeatherElements() {\n    return {\n      icon: document.querySelector('.weather-icon'),\n      temp: document.querySelector('.weather-temp'),\n      condition: document.querySelector('.weather-condition'),\n      location: document.querySelector('.weather-location'),\n      wind: document.querySelector('.weather-wind')\n    };\n  }\n\n  // WMO Weather Code mapping\n  const wmoDescriptions = {\n    0: 'Clear sky', 1: 'Mainly clear', 2: 'Partly cloudy', 3: 'Overcast',\n    45: 'Fog', 48: 'Rime fog',\n    51: 'Light drizzle', 53: 'Drizzle', 55: 'Dense drizzle',\n    56: 'Freezing drizzle', 57: 'Dense freezing drizzle',\n    61: 'Light rain', 63: 'Moderate rain', 65: 'Heavy rain',\n    66: 'Light freezing rain', 67: 'Heavy freezing rain',\n    71: 'Light snow', 73: 'Moderate snow', 75: 'Heavy snow', 77: 'Snow grains',\n    80: 'Light showers', 81: 'Moderate showers', 82: 'Violent showers',\n    85: 'Light snow showers', 86: 'Heavy snow showers',\n    95: 'Thunderstorm', 96: 'Thunderstorm with hail', 99: 'Severe thunderstorm'\n  };\n\n  const wmoIcons = {\n    0: '\u2600\uFE0F', 1: '\uD83C\uDF24\uFE0F', 2: '\u26C5', 3: '\u2601\uFE0F',\n    45: '\uD83C\uDF2B\uFE0F', 48: '\uD83C\uDF2B\uFE0F',\n    51: '\uD83C\uDF26\uFE0F', 53: '\uD83C\uDF26\uFE0F', 55: '\uD83C\uDF26\uFE0F',\n    56: '\uD83C\uDF28\uFE0F', 57: '\uD83C\uDF28\uFE0F',\n    61: '\uD83C\uDF26\uFE0F', 63: '\uD83C\uDF27\uFE0F', 65: '\uD83C\uDF27\uFE0F',\n    66: '\uD83C\uDF28\uFE0F', 67: '\uD83C\uDF28\uFE0F',\n    71: '\uD83C\uDF28\uFE0F', 73: '\u2744\uFE0F', 75: '\u2744\uFE0F', 77: '\u2744\uFE0F',\n    80: '\uD83C\uDF26\uFE0F', 81: '\uD83C\uDF27\uFE0F', 82: '\uD83C\uDF27\uFE0F',\n    85: '\uD83C\uDF28\uFE0F', 86: '\u2744\uFE0F',\n    95: '\u26C8\uFE0F', 96: '\u26C8\uFE0F', 99: '\u26C8\uFE0F'\n  };\n\n  // Wind direction from degrees\n  const windDirs = ['N','NNE','NE','ENE','E','ESE','SE','SSE','S','SSW','SW','WSW','W','WNW','NW','NNW'];\n  function degToDir(deg) {\n    return windDirs[Math.round(deg / 22.5) % 16];\n  }\n\n  // Geocode location via Open-Meteo, with localStorage cache\n  async function geocodeLocation(query) {\n    const cached = safeGet(GEO_CACHE_KEY);\n    if (cached) {\n      try {\n        const geo = JSON.parse(cached);\n        if (geo.query === query) return geo;\n      } catch {}\n    }\n    const resp = await fetch(`https://geocoding-api.open-meteo.com/v1/search?name=${encodeURIComponent(query)}&count=1&language=en&format=json`);\n    if (!resp.ok) throw new Error('Geocoding failed');\n    const data = await resp.json();\n    if (!data.results || !data.results.length) throw new Error('Location not found');\n    const r = data.results[0];\n    const geo = {\n      query,\n      lat: r.latitude,\n      lon: r.longitude,\n      city: r.name,\n      state: r.admin1 || '',\n      country: r.country || '',\n      countryCode: r.country_code || ''\n    };\n    safeSet(GEO_CACHE_KEY, JSON.stringify(geo));\n    return geo;\n  }\n\n  function formatLocation(geo) {\n    // For US locations show \"City, State\", for others show \"City, Country\"\n    if (geo.countryCode === 'US' && geo.state) {\n      return `${geo.city}, ${geo.state}`;\n    }\n    if (geo.country) {\n      return `${geo.city}, ${geo.country}`;\n    }\n    return geo.city;\n  }\n\n  async function fetchWeather(location) {\n    try {\n      const geo = await geocodeLocation(location);\n      const unit = getUnit();\n      const tempUnit = unit === 'metric' ? 'celsius' : 'fahrenheit';\n      const windUnit = unit === 'metric' ? 'kmh' : 'mph';\n      const url = `https://api.open-meteo.com/v1/forecast?latitude=${geo.lat}&longitude=${geo.lon}&current=temperature_2m,weather_code,wind_speed_10m,wind_direction_10m&temperature_unit=${tempUnit}&wind_speed_unit=${windUnit}`;\n      const resp = await fetch(url);\n      if (!resp.ok) throw new Error('Weather fetch failed');\n      const data = await resp.json();\n      const c = data.current;\n      const code = c.weather_code;\n      return {\n        temp: Math.round(c.temperature_2m),\n        condition: wmoDescriptions[code] || 'Unknown',\n        icon: wmoIcons[code] || '\uD83C\uDF24\uFE0F',\n        locationStr: formatLocation(geo),\n        windSpeed: Math.round(c.wind_speed_10m),\n        windDir: degToDir(c.wind_direction_10m),\n        unit\n      };\n    } catch (error) {\n      console.warn('Weather fetch failed:', error);\n      return null;\n    }\n  }\n\n  async function updateWeather() {\n    const weatherWidget = getWeatherElements();\n    if (!weatherWidget.icon || !weatherWidget.temp || !weatherWidget.condition || !weatherWidget.location || !weatherWidget.wind) {\n      console.warn('Weather widget elements not found');\n      return;\n    }\n\n    const location = safeGet(LOCATION_KEY);\n    if (!location) {\n      weatherWidget.location.textContent = 'Set Location';\n      weatherWidget.temp.textContent = '--\\u00B0';\n      weatherWidget.condition.textContent = 'Click \\u2699\\uFE0F to configure';\n      weatherWidget.wind.textContent = '--';\n      weatherWidget.icon.innerHTML = '<span class=\"weather-emoji\">\\uD83C\\uDF24\\uFE0F</span>';\n      return;\n    }\n\n    try {\n      const weather = await fetchWeather(location);\n      if (weather) {\n        const tempSuffix = weather.unit === 'metric' ? '\\u00B0C' : '\\u00B0F';\n        const windLabel = weather.unit === 'metric' ? 'km/h' : 'mph';\n        weatherWidget.location.textContent = weather.locationStr;\n        weatherWidget.temp.textContent = `${weather.temp}${tempSuffix}`;\n        weatherWidget.condition.textContent = weather.condition;\n        weatherWidget.wind.textContent = `Wind: ${weather.windSpeed} ${windLabel} ${weather.windDir}`;\n        weatherWidget.icon.innerHTML = `<span class=\"weather-emoji\">${escapeHtml(weather.icon)}</span>`;\n      }\n    } catch (error) {\n      errorHandler.logError('[Weather] Update Error', error, { function: 'updateWeather' });\n      weatherWidget.location.textContent = 'Weather Error';\n      weatherWidget.temp.textContent = 'Error';\n      weatherWidget.condition.textContent = 'Failed to load';\n      weatherWidget.wind.textContent = '--';\n    }\n  }\n\n  // Weather settings modal\n  const modal = document.getElementById('weather-modal');\n  const locationInput = document.getElementById('weather-location-input');\n\n  document.getElementById('weather-settings')?.addEventListener('click', () => {\n    locationInput.value = safeGet(LOCATION_KEY) || '';\n    // Set unit radio\n    const unit = getUnit();\n    const radio = modal.querySelector(`input[name=\"weather-unit-radio\"][value=\"${unit}\"]`);\n    if (radio) radio.checked = true;\n    modal.classList.add('show');\n    locationInput.focus();\n  });\n\n  document.getElementById('weather-cancel')?.addEventListener('click', () => {\n    modal.classList.remove('show');\n  });\n\n  document.getElementById('weather-save')?.addEventListener('click', () => {\n    const loc = locationInput.value.trim();\n    if (loc) {\n      // Clear geo cache when location changes so it re-geocodes\n      const oldLoc = safeGet(LOCATION_KEY);\n      if (oldLoc !== loc) safeSet(GEO_CACHE_KEY, '');\n      safeSet(LOCATION_KEY, loc);\n      // Save unit preference\n      const unitRadio = modal.querySelector('input[name=\"weather-unit-radio\"]:checked');\n      const newUnit = unitRadio ? unitRadio.value : 'imperial';\n      const oldUnit = getUnit();\n      safeSet(UNIT_KEY, newUnit);\n      // Clear geo cache if unit changed (need fresh weather data)\n      if (oldUnit !== newUnit) safeSet(GEO_CACHE_KEY, '');\n      modal.classList.remove('show');\n      updateWeather();\n    } else {\n      showNotification('Please enter a location (e.g., Hamburg, London, 90210)', 'warning');\n    }\n  });\n\n  wireModal(modal);\n\n  // Close modal on Escape key\n  document.addEventListener('keydown', (e) => {\n    if (e.key === 'Escape' && modal.classList.contains('show')) {\n      modal.classList.remove('show');\n    }\n  });\n\n  // Initialize weather\n  updateWeather();\n  // Update weather every 10 minutes\n  setInterval(updateWeather, DC.POLL.WEATHER);\n})();\n;\n// ========== DIGITAL CLOCK WIDGET ==========\n(function() {\n  const widget = document.getElementById('clock-widget');\n  const render = document.getElementById('clock-render');\n  if (!widget || !render) return;\n\n  const DAYS = ['Sunday','Monday','Tuesday','Wednesday','Thursday','Friday','Saturday'];\n  const MONTHS = ['January','February','March','April','May','June','July','August','September','October','November','December'];\n  const ROMAN = ['XII','I','II','III','IV','V','VI','VII','VIII','IX','X','XI'];\n\n  let currentStyle = safeGet('clock-style') || 'default';\n  let lastChimeHour = -1;\n  let chimePlaying = false;\n  let prevFlipDigits = '';\n  let activeLayout = '';\n  let digitalRefs = null;\n  let tickTimer = null;\n\n  // ===== CHIMES =====\n  function playChimes(count) {\n    if (chimePlaying) return;\n    if (safeGet('clock-chimes') !== 'true') return;\n    chimePlaying = true;\n    const vol = parseInt(safeGet('clock-chime-volume') || '50', 10) / 100;\n    let i = 0;\n    function strike() {\n      if (i >= count) { chimePlaying = false; return; }\n      const bell = new Audio('/assets/sounds/church-bell.mp3');\n      bell.volume = vol;\n      bell.play().catch(() => {});\n      i++;\n      if (i < count) setTimeout(strike, 2500);\n      else setTimeout(() => { chimePlaying = false; }, 2500);\n    }\n    strike();\n  }\n\n  // ===== DATE STRING =====\n  function dateStr(now) {\n    return DAYS[now.getDay()] + ', ' + MONTHS[now.getMonth()] + ' ' + now.getDate() + ', ' + now.getFullYear();\n  }\n\n  function resetRenderLayout() {\n    activeLayout = '';\n    digitalRefs = null;\n  }\n\n  function ensureDigitalLayout() {\n    if (activeLayout !== 'digital') {\n      render.innerHTML =\n        '<div class=\"clock-time\"><span class=\"clock-main\"></span><span class=\"clock-seconds\"></span><span class=\"clock-ampm\"></span></div>' +\n        '<div class=\"clock-date\"></div>';\n      digitalRefs = {\n        main: render.querySelector('.clock-main'),\n        seconds: render.querySelector('.clock-seconds'),\n        ampm: render.querySelector('.clock-ampm'),\n        date: render.querySelector('.clock-date')\n      };\n      activeLayout = 'digital';\n    }\n    return digitalRefs;\n  }\n\n  // ===== STYLE RENDERERS =====\n\n  function renderDefault(now) {\n    const h24 = now.getHours(), m = now.getMinutes(), s = now.getSeconds();\n    const ampm = h24 >= 12 ? 'PM' : 'AM';\n    const h = h24 % 12 || 12;\n    const refs = ensureDigitalLayout();\n    refs.main.textContent = `${h}:${String(m).padStart(2,'0')}`;\n    refs.seconds.textContent = `:${String(s).padStart(2,'0')}`;\n    refs.ampm.textContent = ampm;\n    refs.date.textContent = dateStr(now);\n  }\n\n  function renderLcd(now, cls) {\n    const h24 = now.getHours(), m = now.getMinutes(), s = now.getSeconds();\n    const ampm = h24 >= 12 ? 'PM' : 'AM';\n    const h = h24 % 12 || 12;\n    const refs = ensureDigitalLayout();\n    refs.main.textContent = `${String(h).padStart(2,'0')}:${String(m).padStart(2,'0')}`;\n    refs.seconds.textContent = `:${String(s).padStart(2,'0')}`;\n    refs.ampm.textContent = ampm;\n    refs.date.textContent = dateStr(now);\n  }\n\n  function renderFlip(now) {\n    const h24 = now.getHours(), m = now.getMinutes(), s = now.getSeconds();\n    const ampm = h24 >= 12 ? 'PM' : 'AM';\n    const h = h24 % 12 || 12;\n    const digits = String(h).padStart(2,' ') + String(m).padStart(2,'0') + String(s).padStart(2,'0');\n\n    let html = '<div class=\"flip-clock-row\">';\n    // Hours\n    html += flipCard(digits[0], 0);\n    html += flipCard(digits[1], 1);\n    html += '<span class=\"flip-colon\">:</span>';\n    // Minutes\n    html += flipCard(digits[2], 2);\n    html += flipCard(digits[3], 3);\n    html += '<span class=\"flip-colon\">:</span>';\n    // Seconds\n    html += flipCard(digits[4], 4);\n    html += flipCard(digits[5], 5);\n    html += `<span class=\"flip-ampm\">${ampm}</span>`;\n    html += '</div>';\n    html += `<div class=\"clock-date\">${dateStr(now)}</div>`;\n    render.innerHTML = html;\n    activeLayout = 'flip';\n\n    // Trigger flip animation on changed digits\n    if (prevFlipDigits) {\n      for (let i = 0; i < 6; i++) {\n        if (digits[i] !== prevFlipDigits[i]) {\n          const card = render.querySelector(`.flip-card[data-idx=\"${i}\"]`);\n          if (card) card.classList.add('flipping');\n        }\n      }\n    }\n    prevFlipDigits = digits;\n  }\n\n  function flipCard(digit, idx) {\n    const d = digit === ' ' ? '' : digit;\n    return `<div class=\"flip-card\" data-idx=\"${idx}\"><div class=\"flip-top\">${d}</div><div class=\"flip-bottom\">${d}</div></div>`;\n  }\n\n  function renderBinary(now) {\n    const h24 = now.getHours(), m = now.getMinutes(), s = now.getSeconds();\n    const h = h24 % 12 || 12;\n    const ampm = h24 >= 12 ? 'PM' : 'AM';\n    // 6 columns: H tens, H ones, M tens, M ones, S tens, S ones\n    const cols = [\n      Math.floor(h / 10), h % 10,\n      Math.floor(m / 10), m % 10,\n      Math.floor(s / 10), s % 10\n    ];\n\n    let html = '<div class=\"binary-clock\">';\n    // Labels\n    html += '<div class=\"binary-labels\"><span>H</span><span>H</span><span>M</span><span>M</span><span>S</span><span>S</span></div>';\n    // 4 rows for bits 8,4,2,1\n    for (let bit = 3; bit >= 0; bit--) {\n      html += '<div class=\"binary-row\">';\n      for (let col = 0; col < 6; col++) {\n        const on = (cols[col] >> bit) & 1;\n        html += `<div class=\"binary-dot ${on ? 'on' : ''}\"></div>`;\n      }\n      html += '</div>';\n    }\n    // Value row\n    html += '<div class=\"binary-values\">';\n    for (let col = 0; col < 6; col++) {\n      html += `<span>${cols[col]}</span>`;\n    }\n    html += '</div>';\n    html += `<div class=\"binary-ampm\">${ampm}</div>`;\n    html += '</div>';\n    html += `<div class=\"clock-date\">${dateStr(now)}</div>`;\n    render.innerHTML = html;\n    activeLayout = 'binary';\n  }\n\n  function renderAnalog(now, useRoman) {\n    const h = now.getHours(), m = now.getMinutes(), s = now.getSeconds();\n    const size = 120;\n    const cx = size / 2, cy = size / 2;\n\n    // Angles\n    const sAngle = (s / 60) * 360 - 90;\n    const mAngle = ((m + s / 60) / 60) * 360 - 90;\n    const hAngle = (((h % 12) + m / 60) / 12) * 360 - 90;\n\n    // Number labels\n    let labels = '';\n    for (let i = 1; i <= 12; i++) {\n      const angle = (i / 12) * 2 * Math.PI - Math.PI / 2;\n      const r = 47;\n      const x = cx + r * Math.cos(angle);\n      const y = cy + r * Math.sin(angle);\n      const label = useRoman ? ROMAN[i % 12] : i;\n      const fs = useRoman ? '7' : '9';\n      labels += `<text x=\"${x}\" y=\"${y}\" text-anchor=\"middle\" dominant-baseline=\"central\" fill=\"var(--fg)\" font-size=\"${fs}\" font-weight=\"600\" font-family=\"'Sami Grotesk',sans-serif\">${label}</text>`;\n    }\n\n    // Tick marks\n    let ticks = '';\n    for (let i = 0; i < 60; i++) {\n      const angle = (i / 60) * 2 * Math.PI - Math.PI / 2;\n      const outer = 56;\n      const inner = i % 5 === 0 ? 52 : 54;\n      const x1 = cx + inner * Math.cos(angle);\n      const y1 = cy + inner * Math.sin(angle);\n      const x2 = cx + outer * Math.cos(angle);\n      const y2 = cy + outer * Math.sin(angle);\n      const w = i % 5 === 0 ? 1.5 : 0.5;\n      ticks += `<line x1=\"${x1}\" y1=\"${y1}\" x2=\"${x2}\" y2=\"${y2}\" stroke=\"var(--muted)\" stroke-width=\"${w}\" stroke-linecap=\"round\"/>`;\n    }\n\n    const svg = `<svg class=\"analog-clock-svg\" viewBox=\"0 0 ${size} ${size}\" width=\"${size}\" height=\"${size}\">\n      <circle cx=\"${cx}\" cy=\"${cy}\" r=\"58\" fill=\"none\" stroke=\"var(--border)\" stroke-width=\"2\"/>\n      ${ticks}\n      ${labels}\n      <line x1=\"${cx}\" y1=\"${cy}\" x2=\"${cx + 28 * Math.cos(hAngle * Math.PI / 180)}\" y2=\"${cy + 28 * Math.sin(hAngle * Math.PI / 180)}\" stroke=\"var(--fg)\" stroke-width=\"3\" stroke-linecap=\"round\"/>\n      <line x1=\"${cx}\" y1=\"${cy}\" x2=\"${cx + 38 * Math.cos(mAngle * Math.PI / 180)}\" y2=\"${cy + 38 * Math.sin(mAngle * Math.PI / 180)}\" stroke=\"var(--fg)\" stroke-width=\"2\" stroke-linecap=\"round\"/>\n      <line x1=\"${cx}\" y1=\"${cy}\" x2=\"${cx + 42 * Math.cos(sAngle * Math.PI / 180)}\" y2=\"${cy + 42 * Math.sin(sAngle * Math.PI / 180)}\" stroke=\"#e74c3c\" stroke-width=\"1\" stroke-linecap=\"round\"/>\n      <circle cx=\"${cx}\" cy=\"${cy}\" r=\"3\" fill=\"var(--fg)\"/>\n    </svg>`;\n\n    const ampm = now.getHours() >= 12 ? 'PM' : 'AM';\n    render.innerHTML = `<div class=\"analog-clock-wrap\">${svg}<div class=\"analog-info\"><span class=\"analog-digital\">${(now.getHours() % 12 || 12)}:${String(m).padStart(2,'0')} ${ampm}</span><span class=\"analog-date-sm\">${dateStr(now)}</span></div></div>`;\n    activeLayout = 'analog';\n  }\n\n  // ===== MAIN TICK =====\n  function tick() {\n    const now = new Date();\n    const h = now.getHours() % 12 || 12;\n    const m = now.getMinutes();\n    const s = now.getSeconds();\n\n    // Set style class on widget\n    const nextClassName = 'clock-widget' + (currentStyle !== 'default' ? ' ' + currentStyle : '');\n    if (widget.className !== nextClassName) {\n      widget.className = nextClassName;\n    }\n\n    switch (currentStyle) {\n      case 'lcd': renderLcd(now); break;\n      case 'lcd-blue': renderLcd(now); break;\n      case 'lcd-amber': renderLcd(now); break;\n      case 'lcd-retro': renderLcd(now); break;\n      case 'lcd-taxi': renderLcd(now); break;\n      case 'flip': renderFlip(now); break;\n      case 'binary': renderBinary(now); break;\n      case 'analog': renderAnalog(now, false); break;\n      case 'roman': renderAnalog(now, true); break;\n      default: renderDefault(now);\n    }\n\n    // Hourly chimes\n    if (m === 0 && s === 0 && h !== lastChimeHour) {\n      lastChimeHour = h;\n      playChimes(h);\n    }\n    if (m !== 0) lastChimeHour = -1;\n  }\n\n  function scheduleNextTick() {\n    clearTimeout(tickTimer);\n    const interval = document.hidden ? 60000 : 1000;\n    const delay = interval - (Date.now() % interval) + 25;\n    tickTimer = setTimeout(() => {\n      tick();\n      scheduleNextTick();\n    }, delay);\n  }\n\n  document.addEventListener('visibilitychange', () => {\n    prevFlipDigits = '';\n    resetRenderLayout();\n    tick();\n    scheduleNextTick();\n  });\n\n  tick();\n  scheduleNextTick();\n\n  // ===== SETTINGS MODAL =====\n  const STYLES = [\n    { id: 'default', label: 'Default', icon: '\uD83D\uDD50' },\n    { id: 'lcd', label: 'LCD Green', icon: '\uD83D\uDC9A' },\n    { id: 'lcd-blue', label: 'LCD Blue', icon: '\uD83D\uDC99' },\n    { id: 'lcd-amber', label: 'LCD Amber', icon: '\uD83D\uDFE0' },\n    { id: 'lcd-retro', label: 'LCD Retro', icon: '\uD83D\uDFE9' },\n    { id: 'lcd-taxi', label: 'LCD Taxi', icon: '\uD83D\uDFE1' },\n    { id: 'flip', label: 'Flip Clock', icon: '\uD83D\uDCDF' },\n    { id: 'binary', label: 'Binary', icon: '\uD83D\uDCBB' },\n    { id: 'analog', label: 'Analog', icon: '\u23F0' },\n    { id: 'roman', label: 'Roman', icon: '\uD83C\uDFDB\uFE0F' },\n  ];\n\n  let styleOptionsHtml = '<div class=\"clock-style-grid\">';\n  STYLES.forEach(s => {\n    styleOptionsHtml += `<label class=\"clock-style-option\">\n      <input type=\"radio\" name=\"clock-style-radio\" value=\"${s.id}\">\n      <span class=\"clock-style-card\"><span class=\"clock-style-icon\">${s.icon}</span><span class=\"clock-style-label\">${s.label}</span></span>\n    </label>`;\n  });\n  styleOptionsHtml += '</div>';\n\n  injectModal('clock-settings-modal', `<div id=\"clock-settings-modal\" class=\"weather-modal\">\n    <div class=\"weather-modal-content\" style=\"max-width: 420px;\">\n      <h3>Clock Settings</h3>\n      <div style=\"margin-bottom: 16px;\">\n        <label style=\"display: block; margin-bottom: 8px; font-weight: 600; color: var(--fg);\">Style</label>\n        ${styleOptionsHtml}\n      </div>\n      <div style=\"margin-bottom: 16px; padding-top: 12px; border-top: 1px solid var(--border);\">\n        <label style=\"display: flex; align-items: center; gap: 8px; cursor: pointer; font-weight: 600; color: var(--fg);\">\n          <input type=\"checkbox\" id=\"clock-chimes-toggle\"> Hourly church bell chimes\n        </label>\n        <div style=\"font-size: 0.78rem; color: var(--muted); margin-top: 4px; margin-left: 24px;\">\n          Strikes the number of the hour (e.g., 3 bells at 3:00)\n        </div>\n      </div>\n      <div style=\"margin-bottom: 16px;\" id=\"clock-volume-section\">\n        <label style=\"display: block; margin-bottom: 6px; font-weight: 600; color: var(--fg);\">Volume</label>\n        <div style=\"display: flex; align-items: center; gap: 10px;\">\n          <span style=\"font-size: 0.85rem;\">\uD83D\uDD08</span>\n          <input type=\"range\" id=\"clock-chime-volume\" min=\"0\" max=\"100\" value=\"50\" style=\"flex: 1; accent-color: var(--ok-fg);\">\n          <span style=\"font-size: 0.85rem;\">\uD83D\uDD0A</span>\n          <button id=\"clock-chime-test\" style=\"padding: 4px 10px; font-size: 0.78rem; border-radius: 4px; cursor: pointer;\">Test</button>\n        </div>\n      </div>\n      <div class=\"weather-modal-buttons\">\n        <button id=\"clock-settings-cancel\">Cancel</button>\n        <button id=\"clock-settings-save\">Save</button>\n      </div>\n    </div>\n  </div>`);\n\n  const modal = document.getElementById('clock-settings-modal');\n  const chimesToggle = document.getElementById('clock-chimes-toggle');\n  const volumeSlider = document.getElementById('clock-chime-volume');\n  const volumeSection = document.getElementById('clock-volume-section');\n\n  function loadSettings() {\n    const style = safeGet('clock-style') || 'default';\n    const radio = modal.querySelector(`input[value=\"${style}\"]`);\n    if (radio) radio.checked = true;\n    chimesToggle.checked = safeGet('clock-chimes') === 'true';\n    volumeSlider.value = safeGet('clock-chime-volume') || '50';\n    volumeSection.style.opacity = chimesToggle.checked ? '1' : '0.4';\n  }\n\n  chimesToggle?.addEventListener('change', () => {\n    volumeSection.style.opacity = chimesToggle.checked ? '1' : '0.4';\n  });\n\n  document.getElementById('clock-settings')?.addEventListener('click', () => {\n    loadSettings();\n    modal.classList.add('show');\n  });\n\n  document.getElementById('clock-chime-test')?.addEventListener('click', () => {\n    const vol = parseInt(volumeSlider.value, 10) / 100;\n    const bell = new Audio('/assets/sounds/church-bell.mp3');\n    bell.volume = vol;\n    bell.play().catch(() => {});\n  });\n\n  document.getElementById('clock-settings-save')?.addEventListener('click', () => {\n    const radio = modal.querySelector('input[name=\"clock-style-radio\"]:checked');\n    const style = radio ? radio.value : 'default';\n    safeSet('clock-style', style);\n    safeSet('clock-chimes', String(chimesToggle.checked));\n    safeSet('clock-chime-volume', volumeSlider.value);\n    currentStyle = style;\n    prevFlipDigits = '';\n    resetRenderLayout();\n    tick();\n    scheduleNextTick();\n    modal.classList.remove('show');\n    showNotification('Clock settings saved', 'success', 2000);\n  });\n\n  document.getElementById('clock-settings-cancel')?.addEventListener('click', () => {\n    modal.classList.remove('show');\n  });\n\n  wireModal(modal);\n\n  // Live preview when clicking style options\n  modal?.querySelectorAll('input[name=\"clock-style-radio\"]').forEach(radio => {\n    radio.addEventListener('change', () => {\n      currentStyle = radio.value;\n      prevFlipDigits = '';\n      resetRenderLayout();\n      tick();\n    });\n  });\n})();\n;\n// ========== CALENDAR WIDGET (DC-161) ==========\n// Zero-config for calendars deployed through DashCaddy (Radicale auto-wiring);\n// manual CalDAV/ICS sources via the \u2699\uFE0F settings modal. Weather-widget pattern:\n// compact top-bar display + weather-modal shell + server-backed settings.\n(function() {\n  const errorHandler = new ErrorHandler();\n\n  injectModal('calendar-modal', `<div id=\"calendar-modal\" class=\"weather-modal\">\n    <div class=\"weather-modal-content\" style=\"min-width:560px;max-width:720px;\">\n      <h3>\uD83D\uDCC5 Calendar</h3>\n      <div id=\"calendar-upcoming\" style=\"margin:0 0 14px;\">\n        <div style=\"font-size:0.8rem;color:var(--muted);margin-bottom:6px;\">Next 14 days</div>\n        <div id=\"calendar-upcoming-list\" style=\"display:flex;flex-direction:column;gap:4px;max-height:180px;overflow-y:auto;\">\n          <div style=\"color:var(--muted);font-size:0.85rem;\">No upcoming appointments.</div>\n        </div>\n      </div>\n      <div style=\"margin-top:14px;padding-top:12px;border-top:1px solid var(--border);\">\n        <label style=\"display:block;font-weight:600;color:var(--fg);margin-bottom:8px;\">Calendars</label>\n        <div id=\"calendar-sources-list\" style=\"display:flex;flex-direction:column;gap:6px;margin-bottom:10px;\"></div>\n        <details id=\"calendar-add-details\">\n          <summary style=\"cursor:pointer;font-size:0.85rem;color:var(--accent);\">+ Add a calendar (CalDAV URL or ICS feed)</summary>\n          <div style=\"margin-top:10px;display:flex;flex-direction:column;gap:8px;\">\n            <div style=\"display:flex;gap:8px;\">\n              <label style=\"font-size:0.82rem;\">Type\n                <select id=\"cal-add-type\" style=\"margin-left:6px;background:var(--bg);color:var(--fg);border:1px solid var(--border);border-radius:4px;padding:4px;\">\n                  <option value=\"caldav\">CalDAV</option>\n                  <option value=\"ics\">ICS feed (read-only)</option>\n                </select>\n              </label>\n              <label style=\"font-size:0.82rem;flex:1;\">Name\n                <input type=\"text\" id=\"cal-add-name\" placeholder=\"Work calendar\" maxlength=\"120\" style=\"width:100%;background:var(--bg);color:var(--fg);border:1px solid var(--border);border-radius:4px;padding:4px 8px;\">\n              </label>\n            </div>\n            <label style=\"font-size:0.82rem;\">URL\n              <input type=\"text\" id=\"cal-add-url\" placeholder=\"https://calendar.example.com/user/calendar/\" style=\"width:100%;background:var(--bg);color:var(--fg);border:1px solid var(--border);border-radius:4px;padding:4px 8px;\">\n            </label>\n            <div style=\"display:flex;gap:8px;\">\n              <label style=\"font-size:0.82rem;flex:1;\">User\n                <input type=\"text\" id=\"cal-add-user\" autocomplete=\"off\" style=\"width:100%;background:var(--bg);color:var(--fg);border:1px solid var(--border);border-radius:4px;padding:4px 8px;\">\n              </label>\n              <label style=\"font-size:0.82rem;flex:1;\">Password\n                <input type=\"password\" id=\"cal-add-pass\" autocomplete=\"new-password\" style=\"width:100%;background:var(--bg);color:var(--fg);border:1px solid var(--border);border-radius:4px;padding:4px 8px;\">\n              </label>\n            </div>\n            <div style=\"display:flex;gap:8px;justify-content:flex-end;\">\n              <button id=\"cal-add-test\">Test connection</button>\n              <button id=\"cal-add-save\">Save</button>\n            </div>\n            <div id=\"cal-add-status\" style=\"font-size:0.8rem;color:var(--muted);min-height:1em;\"></div>\n          </div>\n        </details>\n      </div>\n      <div class=\"weather-modal-buttons\"><button id=\"calendar-close\">Close</button></div>\n    </div></div>`);\n\n  const widgetEls = () => ({\n    icon: document.querySelector('.calendar-widget-icon'),\n    text: document.querySelector('.calendar-widget-text'),\n  });\n\n  function fmtWhen(start, allDay) {\n    const d = new Date(start);\n    const today = new Date(); today.setHours(0, 0, 0, 0);\n    const day = new Date(d); day.setHours(0, 0, 0, 0);\n    const days = Math.round((day - today) / 86400000);\n    const dayLabel = days === 0 ? 'Today' : days === 1 ? 'Tomorrow' :\n      d.toLocaleDateString(undefined, { weekday: 'short', month: 'short', day: 'numeric' });\n    const timeLabel = allDay ? 'all-day' : d.toLocaleTimeString(undefined, { hour: 'numeric', minute: '2-digit' });\n    return `${dayLabel} ${timeLabel}`;\n  }\n\n  async function fetchCalendar() {\n    const start = new Date(Date.now() - 86400000);\n    const end = new Date(Date.now() + 14 * 86400000);\n    const resp = await fetch(`/api/v1/calendar/events?start=${start.toISOString()}&end=${end.toISOString()}`, { cache: 'no-store' });\n    if (resp.status === 404) return { notConfigured: true };\n    if (!resp.ok) throw new Error(`Calendar API HTTP ${resp.status}`);\n    return resp.json();\n  }\n\n  function renderWidget(body) {\n    const els = widgetEls();\n    if (!els.icon || !els.text) return;\n    const events = (body && Array.isArray(body.events)) ? body.events : [];\n    if (!events.length) {\n      els.icon.textContent = '\uD83D\uDCC5';\n      els.text.textContent = 'No calendar';\n      return;\n    }\n    const next = events[0];\n    els.icon.textContent = next.allDay ? '\uD83D\uDDD3\uFE0F' : '\u23F0';\n    els.text.innerHTML = `${escapeHtml(next.title || 'Untitled')}\n      <span style=\"color:var(--muted);font-size:0.78em;\">\u00B7 ${escapeHtml(fmtWhen(next.start, next.allDay))}</span>`;\n  }\n\n  function renderUpcoming(body) {\n    const list = document.getElementById('calendar-upcoming-list');\n    if (!list) return;\n    const events = (body && Array.isArray(body.events)) ? body.events : [];\n    if (!events.length) {\n      list.innerHTML = '<div style=\"color:var(--muted);font-size:0.85rem;\">No upcoming appointments.</div>';\n      return;\n    }\n    list.innerHTML = events.slice(0, 12).map(ev =>\n      `<div style=\"display:flex;gap:8px;align-items:baseline;\">\n         <span style=\"font-size:0.78rem;color:var(--muted);white-space:nowrap;\">${escapeHtml(fmtWhen(ev.start, ev.allDay))}</span>\n         <span style=\"font-size:0.85rem;\">${escapeHtml(ev.title || 'Untitled')}</span>\n         ${ev.location ? `<span style=\"font-size:0.75rem;color:var(--muted);\">${escapeHtml(ev.location)}</span>` : ''}\n       </div>`).join('');\n  }\n\n  async function renderSources() {\n    const listEl = document.getElementById('calendar-sources-list');\n    if (!listEl) return;\n    let sources = [];\n    try {\n      const resp = await fetch('/api/v1/calendar/sources', { cache: 'no-store' });\n      if (resp.ok) {\n        const body = await resp.json();\n        sources = (body && Array.isArray(body.sources)) ? body.sources\n          : (Array.isArray(body) ? body : []);\n      }\n    } catch (e) { /* modal still usable */ }\n    if (!sources.length) {\n      listEl.innerHTML = '<div style=\"font-size:0.82rem;color:var(--muted);\">No calendars connected. Deploy Radicale from the App Selector to auto-connect one, or add a CalDAV/ICS URL below.</div>';\n      return;\n    }\n    listEl.innerHTML = sources.map(s => `\n      <div style=\"display:flex;gap:8px;align-items:center;border:1px solid var(--border);border-radius:6px;padding:6px 10px;\">\n        <span style=\"font-size:0.85rem;flex:1;\">${escapeHtml(s.name || s.id)}\n          <span style=\"color:var(--muted);font-size:0.72rem;\">\u00B7 ${escapeHtml(s.type)}${s.autoProvisioned ? ' \u00B7 auto-wired' : ''}</span></span>\n        <button class=\"cal-src-toggle\" data-id=\"${escapeHtml(s.id)}\" data-enabled=\"${s.enabled !== false ? '1' : '0'}\"\n          style=\"font-size:0.75rem;padding:2px 8px;\">${s.enabled !== false ? '\u2713 on' : 'off'}</button>\n        <button class=\"cal-src-del\" data-id=\"${escapeHtml(s.id)}\" style=\"font-size:0.75rem;padding:2px 8px;color:var(--err-fg);\">remove</button>\n      </div>`).join('');\n    listEl.querySelectorAll('.cal-src-toggle').forEach(btn => btn.addEventListener('click', async () => {\n      const id = btn.dataset.id;\n      const enable = btn.dataset.enabled !== '1';\n      await fetch(`/api/v1/calendar/sources/${encodeURIComponent(id)}`, {\n        method: 'PUT', headers: { 'Content-Type': 'application/json' },\n        body: JSON.stringify({ enabled: enable })\n      });\n      renderSources(); refresh();\n    }));\n    listEl.querySelectorAll('.cal-src-del').forEach(btn => btn.addEventListener('click', async () => {\n      const id = btn.dataset.id;\n      await fetch(`/api/v1/calendar/sources/${encodeURIComponent(id)}`, { method: 'DELETE' });\n      renderSources(); refresh();\n    }));\n  }\n\n  async function refresh() {\n    if (refresh._inFlight) return;\n    refresh._inFlight = true;\n    try {\n      const body = await fetchCalendar();\n      renderWidget(body);\n      if (document.getElementById('calendar-modal').style.display === 'flex') {\n        renderUpcoming(body);\n      }\n    } catch (e) {\n      errorHandler.log(e, 'calendar-widget');\n      const els = widgetEls();\n      if (els.text) els.text.textContent = 'Calendar offline';\n    } finally {\n      refresh._inFlight = false;\n    }\n  }\n\n  // ---- Settings modal wiring ----\n  function openModal() {\n    document.getElementById('calendar-modal').style.display = 'flex';\n    renderSources();\n    refresh();\n  }\n  function closeModal() {\n    document.getElementById('calendar-modal').style.display = 'none';\n  }\n\n  function formCreds() {\n    return {\n      type: document.getElementById('cal-add-type').value,\n      name: document.getElementById('cal-add-name').value.trim(),\n      url: document.getElementById('cal-add-url').value.trim(),\n      user: document.getElementById('cal-add-user').value.trim(),\n      pass: document.getElementById('cal-add-pass').value,\n    };\n  }\n\n  function setStatus(msg) {\n    document.getElementById('cal-add-status').textContent = msg;\n  }\n\n  document.getElementById('cal-add-test').addEventListener('click', async () => {\n    const f = formCreds();\n    if (!f.url) { setStatus('Enter a URL first.'); return; }\n    setStatus('Testing\u2026');\n    try {\n      const resp = await fetch('/api/v1/calendar/discover', {\n        method: 'POST', headers: { 'Content-Type': 'application/json' },\n        body: JSON.stringify({ url: f.url, user: f.user, pass: f.pass })\n      });\n      const body = await resp.json();\n      const p = body && body.probe;\n      if (p && p.ok) setStatus(`\u2713 Reachable (${p.server || 'server'})${p.looksLikeCalendar ? ' \u2014 looks like a calendar' : ''}`);\n      else setStatus(`\u2717 ${p && p.error ? p.error : 'Not reachable'}`);\n    } catch (e) {\n      setStatus(`\u2717 ${e.message}`);\n    }\n  });\n\n  document.getElementById('cal-add-save').addEventListener('click', async () => {\n    const f = formCreds();\n    if (!f.name || !f.url) { setStatus('Name and URL are required.'); return; }\n    try {\n      const resp = await fetch('/api/v1/calendar/sources', {\n        method: 'POST', headers: { 'Content-Type': 'application/json' },\n        body: JSON.stringify({ name: f.name, type: f.type, url: f.url, user: f.user, pass: f.pass })\n      });\n      if (!resp.ok) {\n        const body = await resp.json().catch(() => ({}));\n        setStatus(`\u2717 ${body.error || body.message || `HTTP ${resp.status}`}`);\n        return;\n      }\n      setStatus('Saved.');\n      document.getElementById('cal-add-details').open = false;\n      ['cal-add-name', 'cal-add-url', 'cal-add-user', 'cal-add-pass'].forEach(id => { document.getElementById(id).value = ''; });\n      renderSources(); refresh();\n    } catch (e) {\n      setStatus(`\u2717 ${e.message}`);\n    }\n  });\n\n  const calBtn = document.getElementById('calendar-widget');\n  if (calBtn) calBtn.addEventListener('click', openModal);\n  const calSettings = document.getElementById('calendar-settings');\n  if (calSettings) calSettings.addEventListener('click', (e) => { e.stopPropagation(); openModal(); });\n  const calClose = document.getElementById('calendar-close');\n  if (calClose) calClose.addEventListener('click', closeModal);\n\n  window.refreshCalendarWidget = refresh;\n\n  const POLL = (typeof DC !== 'undefined' && DC.POLL && DC.POLL.CALENDAR) || 300000;\n  setInterval(refresh, POLL);\n  setTimeout(refresh, 400);\n})();\n;\n// ========== CONNECT YOUR AI (DC-162) ==========\n// One button, one flow: click \"\uD83E\uDD16 Connect AI\" \u2192 pick Claude/ChatGPT/generic\n// \u2192 DashCaddy mints a dedicated dk_ key + ready-to-paste MCP config. The\n// dashboard's own session does the signing-in; the AI assistant authenticates\n// with the key against POST /api/v1/mcp. Keys listed/revokeable here too.\n(function() {\n  const errorHandler = new ErrorHandler();\n\n  injectModal('ai-connect-modal', `<div id=\"ai-connect-modal\" class=\"weather-modal\">\n    <div class=\"weather-modal-content\" style=\"min-width:560px;max-width:720px;\">\n      <h3>\uD83E\uDD16 Connect your AI assistant</h3>\n      <div id=\"aiconn-intro\" style=\"font-size:0.85rem;color:var(--muted);margin-bottom:12px;\">\n        DashCaddy speaks MCP \u2014 Claude, ChatGPT and other AI assistants can manage your\n        homelab (deploy apps, check health, edit DNS) through one endpoint.\n        Pick an assistant and DashCaddy generates the access key + config for it.\n      </div>\n\n      <div id=\"aiconn-endpoint\" style=\"display:none;margin:0 0 12px;padding:8px 10px;border:1px solid var(--border);border-radius:6px;font-size:0.8rem;\">\n        <span style=\"color:var(--muted);\">MCP endpoint:</span>\n        <code id=\"aiconn-endpoint-url\" style=\"user-select:all;\">\u2014</code>\n        <button id=\"aiconn-copy-endpoint\" style=\"margin-left:8px;font-size:0.75rem;\">Copy</button>\n        <div id=\"aiconn-tools\" style=\"color:var(--muted);margin-top:2px;\"></div>\n      </div>\n\n      <!-- Step 1: pick client -->\n      <div id=\"aiconn-step-pick\">\n        <div style=\"font-weight:600;margin:6px 0 8px;\">Choose your assistant:</div>\n        <div style=\"display:flex;gap:8px;flex-wrap:wrap;\">\n          <button class=\"aiconn-client-btn\" data-client=\"claude\">\uD83D\uDFE0 Claude</button>\n          <button class=\"aiconn-client-btn\" data-client=\"chatgpt\">\uD83D\uDFE2 ChatGPT</button>\n          <button class=\"aiconn-client-btn\" data-client=\"generic\">\uD83D\uDD0C Other / generic</button>\n        </div>\n      </div>\n\n      <!-- Step 2: the generated connection -->\n      <div id=\"aiconn-step-config\" style=\"display:none;margin-top:12px;\">\n        <div style=\"font-weight:600;margin-bottom:6px;\" id=\"aiconn-config-title\">Your access key (shown once):</div>\n        <div style=\"display:flex;gap:6px;align-items:center;margin-bottom:10px;\">\n          <code id=\"aiconn-key\" style=\"flex:1;padding:6px 8px;border:1px solid var(--accent);border-radius:4px;background:color-mix(in srgb, var(--accent) 8%, transparent);user-select:all;word-break:break-all;\">\u2014</code>\n          <button id=\"aiconn-copy-key\">Copy</button>\n        </div>\n        <div style=\"font-weight:600;margin-bottom:6px;\">Paste into your client:</div>\n        <pre id=\"aiconn-snippet\" style=\"white-space:pre-wrap;word-break:break-all;font-size:0.78rem;border:1px solid var(--border);border-radius:6px;padding:10px;max-height:220px;overflow:auto;margin:0 0 8px;\"></pre>\n        <div style=\"display:flex;gap:6px;align-items:center;margin-bottom:8px;\">\n          <button id=\"aiconn-copy-snippet\">Copy config</button>\n          <button id=\"aiconn-back\">\u2190 Choose a different assistant</button>\n        </div>\n        <div id=\"aiconn-client-note\" style=\"font-size:0.78rem;color:var(--muted);margin-bottom:10px;\"></div>\n      </div>\n\n      <!-- Existing connections -->\n      <div style=\"margin-top:14px;padding-top:12px;border-top:1px solid var(--border);\">\n        <div style=\"font-weight:600;margin-bottom:6px;\">Active AI connections</div>\n        <div id=\"aiconn-connections\" style=\"display:flex;flex-direction:column;gap:4px;max-height:160px;overflow-y:auto;\">\n          <div style=\"font-size:0.8rem;color:var(--muted);\">Loading\u2026</div>\n        </div>\n      </div>\n\n      <div class=\"weather-modal-buttons modal-footer-bar\">\n        <span id=\"aiconn-status\" style=\"flex:1;font-size:0.78rem;color:var(--muted);align-self:center;\"></span>\n        <button id=\"aiconn-close\">Close</button>\n      </div>\n    </div></div>`);\n\n  const $ = (id) => document.getElementById(id);\n  let info = null;\n\n  function setStatus(msg) { $('aiconn-status').textContent = msg; }\n\n  async function loadInfo() {\n    try {\n      const resp = await secureFetch('/api/v1/mcp/info');\n      if (!resp.ok) throw new Error(`HTTP ${resp.status}`);\n      const body = await resp.json();\n      info = body;\n      $('aiconn-endpoint').style.display = 'block';\n      $('aiconn-endpoint-url').textContent = body.endpoint;\n      $('aiconn-tools').textContent = `${body.toolCount} tools \u00B7 MCP ${body.protocolVersion} \u00B7 DashCaddy v${body.serverVersion}`;\n    } catch (e) {\n      errorHandler.log(e, 'ai-connect-info');\n      setStatus('MCP endpoint unavailable on this build.');\n    }\n  }\n\n  async function loadConnections() {\n    const listEl = $('aiconn-connections');\n    try {\n      const resp = await secureFetch('/api/v1/mcp/connections');\n      const body = await resp.json().catch(() => ({}));\n      const keys = (body && Array.isArray(body.connections)) ? body.connections : [];\n      if (!keys.length) {\n        listEl.innerHTML = '<div style=\"font-size:0.8rem;color:var(--muted);\">No connections yet \u2014 choose an assistant above.</div>';\n        return;\n      }\n      listEl.innerHTML = keys.map(k => `\n        <div style=\"display:flex;gap:8px;align-items:center;font-size:0.8rem;\">\n          <span style=\"flex:1;\">${escapeHtml(k.name)}\n            <span style=\"color:var(--muted);\">\u00B7 ${(k.scopes || []).join(',')} \u00B7 since ${escapeHtml((k.createdAt || '').slice(0, 10))}${k.lastUsed ? ' \u00B7 last used ' + escapeHtml(String(k.lastUsed).slice(0, 10)) : ''}</span></span>\n          <button class=\"aiconn-revoke\" data-id=\"${escapeHtml(k.id)}\" style=\"font-size:0.75rem;color:var(--err-fg);\">Revoke</button>\n        </div>`).join('');\n      listEl.querySelectorAll('.aiconn-revoke').forEach(btn => btn.addEventListener('click', async () => {\n        btn.disabled = true;\n        try {\n          const resp = await secureFetch(`/api/v1/auth/keys/${encodeURIComponent(btn.dataset.id)}`, { method: 'DELETE' });\n          if (resp.ok) { setStatus('Connection revoked.'); loadConnections(); }\n          else { const b = await resp.json().catch(() => ({})); setStatus(b.error || 'Revoke failed.'); btn.disabled = false; }\n        } catch (e) { setStatus('Revoke failed: ' + e.message); btn.disabled = false; }\n      }));\n    } catch (e) {\n      listEl.innerHTML = '<div style=\"font-size:0.8rem;color:var(--muted);\">Could not load connections.</div>';\n    }\n  }\n\n  async function createConnection(client) {\n    setStatus(`Creating ${client} connection\u2026`);\n    try {\n      const resp = await secureFetch('/api/v1/mcp/config', {\n        method: 'POST',\n        headers: { 'Content-Type': 'application/json' },\n        body: JSON.stringify({ client }),\n      });\n      const body = await resp.json().catch(() => ({}));\n      if (!resp.ok || !body.key) {\n        setStatus(body.error || `Failed (HTTP ${resp.status})`);\n        return;\n      }\n      $('aiconn-key').textContent = body.key;\n      // rev2 config shape: httpConfig = {url, transport, headers,\n      // mcpProtocolVersion} \u2014 the standard Streamable-HTTP connection card.\n      const snippet = body.httpConfig ? JSON.stringify(body.httpConfig, null, 2) : '';\n      $('aiconn-snippet').textContent = snippet || '(see note below)';\n      $('aiconn-client-note').textContent = body.note || '';\n      $('aiconn-config-title').textContent =\n        client === 'chatgpt' ? 'Access key (ChatGPT note below):' : 'Your access key (shown once):';\n      $('aiconn-step-pick').style.display = 'none';\n      $('aiconn-step-config').style.display = 'block';\n      setStatus('');\n      loadConnections();\n    } catch (e) {\n      errorHandler.log(e, 'ai-connect-create');\n      setStatus('Failed: ' + e.message);\n    }\n  }\n\n  function copyText(text, okMsg) {\n    if (navigator.clipboard && navigator.clipboard.writeText) {\n      navigator.clipboard.writeText(text).then(() => setStatus(okMsg)).catch(() => setStatus('Copy failed \u2014 select manually.'));\n    } else {\n      setStatus('Clipboard unavailable \u2014 select manually.');\n    }\n  }\n\n  // ---- wiring ----\n  $('ai-connect-btn').addEventListener('click', () => {\n    $('ai-connect-modal').style.display = 'flex';\n    $('aiconn-step-pick').style.display = 'block';\n    $('aiconn-step-config').style.display = 'none';\n    setStatus('');\n    loadInfo();\n    loadConnections();\n  });\n  $('aiconn-close').addEventListener('click', () => { $('ai-connect-modal').style.display = 'none'; });\n  $('aiconn-back').addEventListener('click', () => {\n    $('aiconn-step-config').style.display = 'none';\n    $('aiconn-step-pick').style.display = 'block';\n  });\n  document.querySelectorAll('.aiconn-client-btn').forEach(btn =>\n    btn.addEventListener('click', () => createConnection(btn.dataset.client)));\n  $('aiconn-copy-key').addEventListener('click', () => copyText($('aiconn-key').textContent, 'Key copied \u2014 paste it into your client.'));\n  $('aiconn-copy-snippet').addEventListener('click', () => copyText($('aiconn-snippet').textContent, 'Config copied.'));\n  $('aiconn-copy-endpoint').addEventListener('click', () => copyText(info ? info.endpoint : $('aiconn-endpoint-url').textContent, 'Endpoint copied.'));\n})();\n;\n// ========== CARD HEALTH & UPDATE BADGES ==========\n(function() {\n  // Fetch health data and update card UI\n  async function refreshCardHealth() {\n    try {\n      const res = await fetch('/api/v1/health-checks/status');\n      const data = await res.json();\n      if (!data.success || !data.status) return;\n\n      for (const [serviceId, svc] of Object.entries(data.status)) {\n        const uptimeEl = document.getElementById('uptime-' + serviceId);\n        const barEl = document.getElementById('uptime-bar-' + serviceId);\n        if (!uptimeEl) continue;\n\n        const uptime24 = svc.uptime?.['24h'];\n        if (uptime24 !== undefined && uptime24 !== null) {\n          const pct = uptime24.toFixed(1);\n          uptimeEl.textContent = `${pct}% uptime`;\n          // Color class\n          uptimeEl.className = 'uptime-chip';\n          if (uptime24 >= 99.9) uptimeEl.classList.add('excellent');\n          else if (uptime24 >= 99) uptimeEl.classList.add('good');\n          else if (uptime24 >= 95) uptimeEl.classList.add('degraded');\n          else uptimeEl.classList.add('poor');\n\n          if (barEl) barEl.style.width = pct + '%';\n        }\n      }\n    } catch (_) {\n      /* Health check API unavailable \u2014 uptime chips stay hidden */\n      console.warn('[Card Badges] Health check API unavailable');\n    }\n  }\n\n  // Track dismissed updates (per session)\n  let dismissedUpdates;\n  try {\n    dismissedUpdates = new Set(JSON.parse(safeSessionGet('dismissed-updates') || '[]'));\n  } catch (_) {\n    /* Session storage unavailable */\n    dismissedUpdates = new Set();\n  }\n\n  // Track global update state for cross-component access\n  let knownUpdates = [];\n\n  // Fetch update data and show badges\n  async function refreshCardUpdates(notifyNew) {\n    try {\n      const res = await fetch('/api/v1/updates/available');\n      const data = await res.json();\n      if (!data.success) return;\n\n      // Clear all update badges first\n      document.querySelectorAll('.update-available-badge').forEach(el => el.classList.remove('visible'));\n\n      const updates = data.updates || [];\n      knownUpdates = updates; // store globally\n\n      // Notify if new updates appeared (periodic check with notification)\n      if (notifyNew && updates.length > 0) {\n        const prev = window._lastKnownUpdateCount || 0;\n        if (prev > 0 && updates.length > prev) {\n          showNotification(`${updates.length} container update(s) available \u2014 click Update Management to review.`, 'info');\n        }\n        window._lastKnownUpdateCount = updates.length;\n      }\n\n      if (!updates.length) return;\n\n      for (const upd of updates) {\n        // Try to match by container name to service id\n        const apps = window.APPS || [];\n        for (const app of apps) {\n          if (app.containerId === upd.containerId || app.id === upd.containerName || app.name === upd.containerName) {\n            // Skip dismissed updates\n            if (dismissedUpdates.has(app.id)) break;\n            const badge = document.getElementById('update-badge-' + app.id);\n            const updateBtn = document.getElementById('update-btn-' + app.id);\n            if (badge) {\n              badge.classList.add('visible');\n              badge.title = `Update available \u2014 click to open Update Management.`;\n              badge.style.cursor = 'pointer';\n              badge.onclick = (e) => {\n                e.stopPropagation();\n                // Open Update Management modal focused on this app\n                if (window.openUpdateModal) window.openUpdateModal(app.id);\n              };\n            }\n            // Highlight update button if update is available\n            if (updateBtn) {\n              updateBtn.style.background = '#f97316';\n              updateBtn.style.borderColor = '#f97316';\n              updateBtn.style.boxShadow = '0 0 6px #f9731688';\n              updateBtn.title = `Update available \u2014 click to open Update Management.`;\n            }\n            break;\n          }\n        }\n      }\n    } catch (_) {\n      /* Updates API unavailable \u2014 badges stay hidden */\n      console.warn('[Card Badges] Updates API unavailable');\n    }\n  }\n\n  // Run health and update checks after main refresh, and periodically\n  function scheduleCardEnhancements() {\n    // Initial load (delayed to not compete with main probe checks)\n    setTimeout(() => {\n      refreshCardHealth();\n      refreshCardUpdates();\n    }, 5000);\n\n    // Periodic refresh every 60 seconds \u2014 notify on new updates detected\n    setInterval(() => {\n      refreshCardHealth();\n      refreshCardUpdates(true); // true = notify if new updates found\n    }, 60000);\n  }\n\n  // Hook into main refresh cycle\n  const origRefreshAll = window.refreshAll;\n  if (origRefreshAll) {\n    window.refreshAll = async function() {\n      try {\n        await origRefreshAll();\n        // Refresh health data after main status check\n        setTimeout(refreshCardHealth, 1000);\n      } catch (e) {\n        console.warn('[Card Badges] Error in refreshAll hook:', e.message);\n      }\n    };\n  }\n\n  scheduleCardEnhancements();\n})();\n;\n// ========== THEME PICKER + THEME BUILDER ==========\n(function () {\n  var themeBeforeBuilder = null;\n  var editingSlug = null;\n  var advancedOverrides = {}; // tracks which advanced fields user manually changed\n\n  // Display names for built-in themes\n  var THEME_LABELS = {\n    dark: 'Dark',\n    light: 'Light',\n    blue: 'Blue',\n    black: 'Black',\n    nord: 'Nord',\n    dracula: 'Dracula',\n    'solarized-dark': 'Solarized Dark',\n    'solarized-light': 'Solarized Light',\n    taxi: 'Taxi',\n    ocean: 'Ocean',\n  };\n\n  // Color picker field definitions: [css-prop, label, section]\n  var FIELDS = [\n    ['bg',            'Background',    'base'],\n    ['card-base',     'Card',          'base'],\n    ['fg',            'Text',          'base'],\n    ['muted',         'Muted Text',    'base'],\n    ['border',        'Border',        'base'],\n    ['accent',        'Accent',        'accent'],\n    ['accent-strong', 'Accent Strong', 'accent'],\n    ['ok-bg',         'OK Background', 'status'],\n    ['ok-fg',         'OK Text',       'status'],\n    ['bad-bg',        'Error Bg',      'status'],\n    ['bad-fg',        'Error Text',    'status'],\n    ['dot-ok',        'Dot OK',        'status'],\n    ['dot-bad',       'Dot Error',     'status'],\n    ['uptime',        'Uptime Bar',    'status'],\n    ['hover',         'Hover',         'advanced'],\n    ['card-hover',    'Card Hover',    'advanced'],\n    ['base',          'Tags/Badges',   'advanced'],\n    ['fg-muted',      'Dim Text',      'advanced'],\n    ['success',       'Success',       'advanced'],\n    ['error',         'Error',         'advanced'],\n    ['warning',       'Warning',       'advanced'],\n  ];\n\n  // \u2500\u2500\u2500 Theme Cycle Button \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\n  var themeBtn = document.getElementById('theme');\n  if (!themeBtn) return;\n  var themeLabel = document.getElementById('theme-label');\n\n  function getLabelFor(t) {\n    if (THEME_LABELS[t]) return THEME_LABELS[t];\n    var userThemes = safeGetJSON(window.USER_THEMES_KEY, {});\n    if (userThemes[t]) return userThemes[t].name || t;\n    return t;\n  }\n\n  function updateLabel() {\n    if (themeLabel) themeLabel.textContent = getLabelFor(window.getActiveTheme());\n  }\n\n  themeBtn.addEventListener('click', function () {\n    var list = window.THEMES.slice();\n    var current = window.getActiveTheme();\n    var idx = list.indexOf(current);\n    var next = list[(idx + 1) % list.length];\n    window.applyTheme(next);\n    updateLabel();\n  });\n\n  updateLabel();\n\n  // \u2500\u2500\u2500 Theme Builder Modal \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\n  function buildFieldsHTML() {\n    var sections = { base: 'Base Colors', accent: 'Accent', status: 'Status', advanced: 'Advanced (auto-derived)' };\n    var grouped = {};\n    FIELDS.forEach(function (f) {\n      if (!grouped[f[2]]) grouped[f[2]] = [];\n      grouped[f[2]].push(f);\n    });\n\n    var html = '';\n    Object.keys(sections).forEach(function (key) {\n      if (key === 'advanced') {\n        html += '<div id=\"theme-builder-advanced-toggle\" class=\"theme-builder-advanced-toggle\" style=\"margin:12px 0 4px;cursor:pointer;color:var(--accent);font-size:.85rem;user-select:none;\">Show advanced colors &#9660;</div>';\n        html += '<div id=\"theme-builder-advanced\" class=\"theme-builder-section\" style=\"display:none;\">';\n      } else {\n        html += '<div class=\"theme-builder-section\">';\n      }\n      html += '<div class=\"theme-builder-section-title\">' + sections[key] + '</div>';\n      (grouped[key] || []).forEach(function (f) {\n        html += '<div class=\"theme-builder-row\">' +\n          '<span class=\"theme-builder-label\">' + f[1] + '</span>' +\n          '<input type=\"color\" class=\"theme-builder-color\" data-prop=\"' + f[0] + '\"' + (key === 'advanced' ? ' data-advanced=\"1\"' : '') + ' value=\"#000000\" />' +\n          '<span class=\"theme-builder-hex\" data-hex=\"' + f[0] + '\">#000000</span>' +\n          '</div>';\n      });\n      html += '</div>';\n    });\n    return html;\n  }\n\n  function buildStartFromOptions() {\n    return window.THEMES.map(function (t) {\n      return '<option value=\"' + t + '\">' + getLabelFor(t) + '</option>';\n    }).join('');\n  }\n\n  var modalHTML = '<div id=\"theme-builder-modal\" class=\"weather-modal\">' +\n    '<div class=\"weather-modal-content\" style=\"min-width:420px;max-width:560px;\">' +\n    '<h3>Theme Builder</h3>' +\n\n    // Edit existing user themes dropdown\n    '<div id=\"theme-builder-existing\" style=\"margin-bottom:16px;display:none;\">' +\n    '<label style=\"font-size:.85rem;color:var(--muted);margin-right:8px;\">Edit:</label>' +\n    '<select id=\"theme-builder-edit-select\" style=\"padding:6px 10px;background:var(--card-bg);color:var(--fg);border:1px solid var(--border);border-radius:6px;font-size:.85rem;margin-right:8px;\">' +\n    '<option value=\"\">\u2014 New Theme \u2014</option>' +\n    '</select>' +\n    '<button id=\"theme-builder-delete\" style=\"padding:4px 10px;background:color-mix(in srgb,var(--bad-fg) 15%,transparent);border:1px solid var(--bad-fg);color:var(--bad-fg);border-radius:6px;font-size:.8rem;cursor:pointer;\">Delete</button>' +\n    '</div>' +\n\n    '<div style=\"margin-bottom:16px;\">' +\n    '<label style=\"font-size:.85rem;color:var(--muted);margin-right:8px;\">Name:</label>' +\n    '<input type=\"text\" id=\"theme-builder-name\" maxlength=\"20\" placeholder=\"My Theme\" ' +\n    'style=\"padding:6px 10px;background:var(--card-bg);color:var(--fg);border:1px solid var(--border);border-radius:6px;font-size:.85rem;width:140px;\" />' +\n    '</div>' +\n\n    '<div style=\"margin-bottom:16px;display:flex;align-items:center;\">' +\n    '<label style=\"font-size:.85rem;color:var(--muted);margin-right:8px;cursor:pointer;\" for=\"theme-builder-lightbg\">' +\n    '<input type=\"checkbox\" id=\"theme-builder-lightbg\" style=\"margin-right:6px;cursor:pointer;vertical-align:middle;\" />' +\n    'Light background (use dark logo)</label>' +\n    '</div>' +\n\n    '<div style=\"margin-bottom:16px;\">' +\n    '<label style=\"font-size:.85rem;color:var(--muted);margin-right:8px;\">Start from:</label>' +\n    '<select id=\"theme-builder-start\" style=\"padding:6px 10px;background:var(--card-bg);color:var(--fg);border:1px solid var(--border);border-radius:6px;font-size:.85rem;\">' +\n    buildStartFromOptions() +\n    '</select>' +\n    '</div>' +\n\n    '<div class=\"theme-builder-preview\" id=\"theme-builder-preview\">' +\n    '<div class=\"theme-builder-card\" id=\"theme-preview-card\">' +\n    '<div class=\"preview-title\">Sample Card</div>' +\n    '<div class=\"preview-muted\">Secondary text preview</div>' +\n    '<div class=\"preview-badges\">' +\n    '<span class=\"preview-badge\" id=\"preview-badge-ok\">ON</span>' +\n    '<span class=\"preview-badge\" id=\"preview-badge-bad\">OFF</span>' +\n    '</div>' +\n    '<div class=\"preview-dots\">' +\n    '<span><span class=\"preview-dot\" id=\"preview-dot-ok\"></span> Online</span>' +\n    '<span><span class=\"preview-dot\" id=\"preview-dot-bad\"></span> Offline</span>' +\n    '</div>' +\n    '<button class=\"preview-btn\" id=\"preview-accent-btn\">Accent Button</button>' +\n    '</div>' +\n    '</div>' +\n\n    buildFieldsHTML() +\n\n    '<div class=\"weather-modal-buttons\">' +\n    '<button id=\"theme-builder-cancel\">Cancel</button>' +\n    '<button id=\"theme-builder-import\" style=\"margin-left:auto;\" title=\"Import theme from JSON file\">Import</button>' +\n    '<button id=\"theme-builder-export\" title=\"Export theme as JSON file\">Export</button>' +\n    '<button id=\"theme-builder-save\" class=\"btn-accent\">Save Theme</button>' +\n    '</div>' +\n    '</div></div>';\n\n  injectModal('theme-builder-modal', modalHTML);\n\n  var modal = document.getElementById('theme-builder-modal');\n  var startSelect = document.getElementById('theme-builder-start');\n  var nameInput = document.getElementById('theme-builder-name');\n  var editSelect = document.getElementById('theme-builder-edit-select');\n  var existingSection = document.getElementById('theme-builder-existing');\n  var lightBgCheck = document.getElementById('theme-builder-lightbg');\n  var pickers = modal.querySelectorAll('.theme-builder-color');\n  var advancedSection = document.getElementById('theme-builder-advanced');\n  var advancedToggle = document.getElementById('theme-builder-advanced-toggle');\n  var exportBtn = document.getElementById('theme-builder-export');\n\n  // \u2500\u2500\u2500 Advanced toggle \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\n  var advancedVisible = false;\n  advancedToggle.addEventListener('click', function () {\n    advancedVisible = !advancedVisible;\n    advancedSection.style.display = advancedVisible ? '' : 'none';\n    advancedToggle.innerHTML = advancedVisible\n      ? 'Hide advanced colors &#9650;'\n      : 'Show advanced colors &#9660;';\n  });\n\n  // \u2500\u2500\u2500 Color picker helpers \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\n  function getCurrentColors() {\n    var colors = {};\n    pickers.forEach(function (p) {\n      colors[p.dataset.prop] = p.value;\n    });\n    colors['card-bg'] = colors['card-base'];\n    return colors;\n  }\n\n  function getBaseColors() {\n    var colors = {};\n    pickers.forEach(function (p) {\n      if (!p.dataset.advanced) colors[p.dataset.prop] = p.value;\n    });\n    colors['card-bg'] = colors['card-base'];\n    if (lightBgCheck.checked) colors.lightBg = true;\n    return colors;\n  }\n\n  function updateAdvancedFromDerived() {\n    var base = getBaseColors();\n    var derived = window.deriveExtendedColors ? window.deriveExtendedColors(base) : {};\n    pickers.forEach(function (p) {\n      if (p.dataset.advanced && !advancedOverrides[p.dataset.prop]) {\n        var val = derived[p.dataset.prop] || '#333333';\n        p.value = val;\n        var hex = modal.querySelector('[data-hex=\"' + p.dataset.prop + '\"]');\n        if (hex) hex.textContent = val.toUpperCase();\n      }\n    });\n  }\n\n  function loadThemeIntoPickers(themeName) {\n    var colors = window.THEME_COLORS[themeName];\n    if (!colors) return;\n    advancedOverrides = {};\n    pickers.forEach(function (p) {\n      var val = colors[p.dataset.prop] || '#000000';\n      if (val.startsWith('rgba') || val.startsWith('color-mix')) val = '#333333';\n      p.value = val;\n      var hex = modal.querySelector('[data-hex=\"' + p.dataset.prop + '\"]');\n      if (hex) hex.textContent = val.toUpperCase();\n    });\n    lightBgCheck.checked = !!colors.lightBg;\n    updatePreview();\n  }\n\n  function loadUserThemeIntoPickers(slug) {\n    var userThemes = safeGetJSON(window.USER_THEMES_KEY, {});\n    var theme = userThemes[slug];\n    if (!theme) return;\n    advancedOverrides = {};\n    pickers.forEach(function (p) {\n      var val = theme[p.dataset.prop] || '#000000';\n      p.value = val;\n      var hex = modal.querySelector('[data-hex=\"' + p.dataset.prop + '\"]');\n      if (hex) hex.textContent = val.toUpperCase();\n      // If theme has explicit advanced values, mark as overridden\n      if (p.dataset.advanced && theme[p.dataset.prop]) {\n        advancedOverrides[p.dataset.prop] = true;\n      }\n    });\n    nameInput.value = theme.name || '';\n    lightBgCheck.checked = !!theme.lightBg;\n    // Fill any missing advanced fields from derivation\n    updateAdvancedFromDerived();\n    updatePreview();\n  }\n\n  function updatePreview() {\n    var c = getCurrentColors();\n    var preview = document.getElementById('theme-builder-preview');\n    var card = document.getElementById('theme-preview-card');\n    var title = card.querySelector('.preview-title');\n    var muted = card.querySelector('.preview-muted');\n    var badgeOk = document.getElementById('preview-badge-ok');\n    var badgeBad = document.getElementById('preview-badge-bad');\n    var dotOk = document.getElementById('preview-dot-ok');\n    var dotBad = document.getElementById('preview-dot-bad');\n    var btn = document.getElementById('preview-accent-btn');\n    var dots = card.querySelector('.preview-dots');\n\n    preview.style.background = c['bg'];\n    card.style.background = c['card-base'];\n    card.style.borderColor = c['border'];\n    title.style.color = c['fg'];\n    muted.style.color = c['muted'];\n    badgeOk.style.background = c['ok-bg'];\n    badgeOk.style.color = c['ok-fg'];\n    badgeBad.style.background = c['bad-bg'];\n    badgeBad.style.color = c['bad-fg'];\n    dotOk.style.background = c['dot-ok'];\n    dotBad.style.background = c['dot-bad'];\n    dots.style.color = c['fg'];\n    btn.style.background = c['accent'];\n    btn.style.color = c['bg'];\n  }\n\n  function applyColorsLive(colors) {\n    // Include derived colors for full live preview\n    var derived = window.deriveExtendedColors ? window.deriveExtendedColors(colors) : {};\n    window.THEME_PROPS.forEach(function (prop) {\n      var val = colors[prop] || derived[prop];\n      if (val) {\n        document.documentElement.style.setProperty('--' + prop, val);\n      }\n    });\n  }\n\n  // Wire up color pickers\n  pickers.forEach(function (p) {\n    p.addEventListener('input', function () {\n      var hex = modal.querySelector('[data-hex=\"' + p.dataset.prop + '\"]');\n      if (hex) hex.textContent = p.value.toUpperCase();\n\n      // Track manual advanced overrides\n      if (p.dataset.advanced) {\n        advancedOverrides[p.dataset.prop] = true;\n      } else {\n        // Base color changed \u2014 re-derive advanced values (unless overridden)\n        updateAdvancedFromDerived();\n      }\n\n      updatePreview();\n      applyColorsLive(getCurrentColors());\n    });\n  });\n\n  // Light-bg checkbox should re-derive advanced colors\n  lightBgCheck.addEventListener('change', function () {\n    updateAdvancedFromDerived();\n    updatePreview();\n    applyColorsLive(getCurrentColors());\n  });\n\n  startSelect.addEventListener('change', function () {\n    advancedOverrides = {};\n    loadThemeIntoPickers(startSelect.value);\n    applyColorsLive(getCurrentColors());\n  });\n\n  // Populate and refresh the edit-existing dropdown\n  function refreshEditDropdown() {\n    var userThemes = safeGetJSON(window.USER_THEMES_KEY, {});\n    var slugs = Object.keys(userThemes);\n    editSelect.innerHTML = '<option value=\"\">\u2014 New Theme \u2014</option>';\n    slugs.forEach(function (slug) {\n      var opt = document.createElement('option');\n      opt.value = slug;\n      opt.textContent = userThemes[slug].name || slug;\n      editSelect.appendChild(opt);\n    });\n    existingSection.style.display = slugs.length ? '' : 'none';\n  }\n\n  // Also refresh \"Start from\" options\n  function refreshStartFrom() {\n    startSelect.innerHTML = buildStartFromOptions();\n  }\n\n  // Edit dropdown change\n  editSelect.addEventListener('change', function () {\n    var slug = this.value;\n    if (slug) {\n      editingSlug = slug;\n      loadUserThemeIntoPickers(slug);\n      applyColorsLive(getCurrentColors());\n    } else {\n      editingSlug = null;\n      advancedOverrides = {};\n      nameInput.value = '';\n      startSelect.value = window.getActiveTheme();\n      loadThemeIntoPickers(startSelect.value);\n    }\n    exportBtn.style.display = editingSlug ? '' : 'none';\n  });\n\n  function openBuilder() {\n    themeBeforeBuilder = window.getActiveTheme();\n    editingSlug = null;\n    advancedOverrides = {};\n\n    // Reset advanced section to collapsed\n    advancedVisible = false;\n    advancedSection.style.display = 'none';\n    advancedToggle.innerHTML = 'Show advanced colors &#9660;';\n\n    refreshEditDropdown();\n    refreshStartFrom();\n\n    var userThemes = safeGetJSON(window.USER_THEMES_KEY, {});\n    if (userThemes[themeBeforeBuilder]) {\n      // Active theme is a user theme \u2014 open it for editing\n      editSelect.value = themeBeforeBuilder;\n      editingSlug = themeBeforeBuilder;\n      loadUserThemeIntoPickers(themeBeforeBuilder);\n    } else {\n      editSelect.value = '';\n      nameInput.value = '';\n      startSelect.value = themeBeforeBuilder;\n      loadThemeIntoPickers(themeBeforeBuilder);\n    }\n\n    exportBtn.style.display = editingSlug ? '' : 'none';\n    modal.classList.add('show');\n  }\n\n  var customizeBtn = document.getElementById('theme-customize-btn');\n  if (customizeBtn) {\n    customizeBtn.addEventListener('click', function () { openBuilder(); });\n  }\n\n  // \u2500\u2500\u2500 Save \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\n  document.getElementById('theme-builder-save').addEventListener('click', function () {\n    var colors = getCurrentColors();\n    var name = nameInput.value.trim();\n    if (!name) {\n      showNotification('Please enter a theme name', 'warning', 3000);\n      nameInput.focus();\n      return;\n    }\n\n    var userThemes = safeGetJSON(window.USER_THEMES_KEY, {});\n    var slug;\n    var oldSlug = null;\n\n    if (editingSlug) {\n      slug = editingSlug;\n      // If name changed, re-slugify and potentially rename\n      var newSlug = window.slugifyThemeName(name, editingSlug);\n      if (newSlug !== editingSlug) {\n        oldSlug = editingSlug;\n        delete userThemes[editingSlug];\n        var idx = window.THEMES.indexOf(editingSlug);\n        if (idx !== -1) window.THEMES.splice(idx, 1);\n        delete window.THEME_COLORS[editingSlug];\n        slug = newSlug;\n      }\n    } else {\n      slug = window.slugifyThemeName(name);\n    }\n\n    // Build theme data with ALL color properties\n    var themeData = { name: name };\n    if (lightBgCheck.checked) themeData.lightBg = true;\n    window.THEME_PROPS.forEach(function (p) {\n      if (colors[p]) themeData[p] = colors[p];\n    });\n\n    // Update localStorage cache immediately for instant UI\n    userThemes[slug] = themeData;\n    safeSet(window.USER_THEMES_KEY, JSON.stringify(userThemes));\n\n    // Clear inline preview properties\n    window.clearCustomProperties();\n\n    // Re-inject CSS and apply\n    window.injectUserThemeStyles();\n    window.applyTheme(slug);\n    modal.classList.remove('show');\n    updateLabel();\n\n    // Save to server (source of truth)\n    var apiColors = {};\n    window.THEME_PROPS.forEach(function (p) { if (colors[p]) apiColors[p] = colors[p]; });\n\n    // If slug changed, delete the old one from server\n    if (oldSlug) {\n      secureFetch('/api/v1/themes/' + oldSlug, { method: 'DELETE' }).catch(function () {});\n    }\n\n    secureFetch('/api/v1/themes/' + slug, {\n      method: 'POST',\n      headers: { 'Content-Type': 'application/json' },\n      body: JSON.stringify({ name: name, colors: apiColors, lightBg: lightBgCheck.checked })\n    }).then(function () {\n      showNotification(name + ' theme saved', 'success', 3000);\n    }).catch(function () {\n      showNotification(name + ' theme saved locally (server sync failed)', 'warning', 3000);\n    });\n  });\n\n  // \u2500\u2500\u2500 Cancel \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\n  document.getElementById('theme-builder-cancel').addEventListener('click', function () {\n    modal.classList.remove('show');\n    window.clearCustomProperties();\n    if (themeBeforeBuilder) {\n      window.applyTheme(themeBeforeBuilder);\n    }\n  });\n\n  // \u2500\u2500\u2500 Delete \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\n  document.getElementById('theme-builder-delete').addEventListener('click', function () {\n    if (!editingSlug) return;\n\n    var userThemes = safeGetJSON(window.USER_THEMES_KEY, {});\n    var name = userThemes[editingSlug] ? userThemes[editingSlug].name : editingSlug;\n\n    if (!confirm('Delete \"' + name + '\" theme?')) return;\n\n    var slugToDelete = editingSlug;\n\n    // Update localStorage cache immediately\n    delete userThemes[slugToDelete];\n    safeSet(window.USER_THEMES_KEY, JSON.stringify(userThemes));\n\n    // Remove from runtime\n    var idx = window.THEMES.indexOf(slugToDelete);\n    if (idx !== -1) window.THEMES.splice(idx, 1);\n    delete window.THEME_COLORS[slugToDelete];\n\n    window.clearCustomProperties();\n    window.injectUserThemeStyles();\n\n    var fallback = themeBeforeBuilder && themeBeforeBuilder !== slugToDelete ? themeBeforeBuilder : 'dark';\n    window.applyTheme(fallback);\n\n    editingSlug = null;\n    modal.classList.remove('show');\n    updateLabel();\n\n    // Delete from server\n    secureFetch('/api/v1/themes/' + slugToDelete, { method: 'DELETE' }).then(function () {\n      showNotification(name + ' theme deleted', 'success', 3000);\n    }).catch(function () {\n      showNotification(name + ' theme deleted locally (server sync failed)', 'warning', 3000);\n    });\n  });\n\n  // \u2500\u2500\u2500 Export \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\n  document.getElementById('theme-builder-export').addEventListener('click', function () {\n    if (!editingSlug) {\n      showNotification('Save the theme first, then export', 'warning', 3000);\n      return;\n    }\n    var userThemes = safeGetJSON(window.USER_THEMES_KEY, {});\n    var theme = userThemes[editingSlug];\n    if (!theme) return;\n\n    var exportData = {\n      _dashcaddy_theme: true,\n      version: '1.0',\n      exportDate: new Date().toISOString(),\n      slug: editingSlug,\n      name: theme.name,\n      lightBg: theme.lightBg || false,\n      colors: {}\n    };\n    window.THEME_PROPS.forEach(function (p) {\n      if (theme[p]) exportData.colors[p] = theme[p];\n    });\n\n    var blob = new Blob([JSON.stringify(exportData, null, 2)], { type: 'application/json' });\n    var url = URL.createObjectURL(blob);\n    var a = document.createElement('a');\n    a.href = url;\n    a.download = editingSlug + '-theme.json';\n    document.body.appendChild(a);\n    a.click();\n    document.body.removeChild(a);\n    URL.revokeObjectURL(url);\n    showNotification('Theme exported as ' + editingSlug + '-theme.json', 'success', 3000);\n  });\n\n  // \u2500\u2500\u2500 Import \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\n  document.getElementById('theme-builder-import').addEventListener('click', function () {\n    var input = document.createElement('input');\n    input.type = 'file';\n    input.accept = '.json';\n    input.onchange = function (e) {\n      var file = e.target.files[0];\n      if (!file) return;\n      var reader = new FileReader();\n      reader.onload = function (ev) {\n        try {\n          var data = JSON.parse(ev.target.result);\n\n          // Support both wrapped format and raw theme format\n          var themeName, themeColors, themeLightBg;\n          if (data._dashcaddy_theme && data.colors) {\n            // Wrapped export format\n            themeName = data.name || 'Imported';\n            themeColors = data.colors;\n            themeLightBg = data.lightBg || false;\n          } else if (data.name && (data.bg || data['card-base'])) {\n            // Raw theme JSON (same format as server files)\n            themeName = data.name;\n            themeColors = {};\n            window.THEME_PROPS.forEach(function (p) { if (data[p]) themeColors[p] = data[p]; });\n            themeLightBg = data.lightBg || false;\n          } else {\n            throw new Error('Not a valid DashCaddy theme file');\n          }\n\n          // Load into builder\n          nameInput.value = themeName;\n          lightBgCheck.checked = !!themeLightBg;\n          editingSlug = null;\n          editSelect.value = '';\n          advancedOverrides = {};\n\n          // Apply colors to pickers\n          pickers.forEach(function (p) {\n            var val = themeColors[p.dataset.prop] || '#000000';\n            p.value = val;\n            var hex = modal.querySelector('[data-hex=\"' + p.dataset.prop + '\"]');\n            if (hex) hex.textContent = val.toUpperCase();\n            if (p.dataset.advanced && themeColors[p.dataset.prop]) {\n              advancedOverrides[p.dataset.prop] = true;\n            }\n          });\n\n          // Fill any missing advanced fields\n          updateAdvancedFromDerived();\n          updatePreview();\n          applyColorsLive(getCurrentColors());\n          exportBtn.style.display = 'none';\n          showNotification('\"' + themeName + '\" loaded into builder. Click Save to keep it.', 'success', 5000);\n        } catch (err) {\n          showNotification('Import failed: ' + err.message, 'error', 5000);\n        }\n      };\n      reader.readAsText(file);\n    };\n    input.click();\n  });\n\n  // \u2500\u2500\u2500 Modal close handling \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\n  wireModal(modal);\n\n  modal.addEventListener('click', function (e) {\n    if (e.target === modal) {\n      window.clearCustomProperties();\n      if (themeBeforeBuilder) window.applyTheme(themeBeforeBuilder);\n    }\n  });\n})();\n;\n// License Management UI\n(function() {\n  // Inject license modal HTML\n  injectModal('license-modal', `<div id=\"license-modal\" class=\"weather-modal\">\n    <div class=\"weather-modal-content\" style=\"min-width: 420px; max-width: 520px;\">\n      <h3>DashCaddy License</h3>\n      <p style=\"font-size: 0.85rem; color: var(--muted); margin: 0 0 16px;\">\n        Activate a license code to unlock premium features.\n      </p>\n\n      <div id=\"license-status-section\" style=\"margin-bottom: 16px;\">\n        <div id=\"license-badge\" style=\"display: inline-flex; align-items: center; gap: 6px; padding: 6px 14px; border-radius: 20px; font-size: 0.85rem; font-weight: 600; margin-bottom: 12px;\">\n          <span id=\"license-badge-icon\"></span>\n          <span id=\"license-badge-text\"></span>\n        </div>\n        <div id=\"license-details\" style=\"font-size: 0.85rem; color: var(--muted); line-height: 1.6;\"></div>\n      </div>\n\n      <div id=\"license-activate-section\">\n        <label class=\"form-label-bold\">License Code:</label>\n        <input type=\"text\" id=\"license-code-input\" placeholder=\"DC-XXXXX-XXXXX-XXXXX-XXXXX-XXXXX\"\n          maxlength=\"35\" spellcheck=\"false\" autocomplete=\"off\"\n          style=\"width: 100%; padding: 10px 12px; border: 1px solid var(--border); border-radius: 4px; background: var(--card-bg); color: var(--fg); font-size: 1rem; font-family: monospace; letter-spacing: 1px;\" />\n        <p class=\"tiny-hint\">Enter your license code to activate premium features</p>\n      </div>\n\n      <div id=\"license-features\" style=\"margin-top: 16px;\">\n        <label class=\"form-label-bold\" style=\"margin-bottom: 8px; display: block;\">Premium Features:</label>\n        <div id=\"license-feature-list\" style=\"display: grid; gap: 8px;\"></div>\n      </div>\n\n      <div id=\"license-error\" style=\"display: none; margin-top: 12px; padding: 10px; border-radius: 4px; background: rgba(231,76,60,0.15); color: var(--bad-fg); font-size: 0.85rem;\"></div>\n      <div id=\"license-success\" style=\"display: none; margin-top: 12px; padding: 10px; border-radius: 4px; background: rgba(46,204,113,0.15); color: var(--ok-fg); font-size: 0.85rem;\"></div>\n\n      <div class=\"weather-modal-buttons\" style=\"margin-top: 16px;\">\n        <button id=\"license-cancel\">Close</button>\n        <button id=\"license-deactivate\" class=\"btn-accent\" style=\"display: none; background: var(--bad-bg); border-color: var(--bad-fg); color: var(--bad-fg);\">Deactivate</button>\n        <button id=\"license-activate\" class=\"btn-accent\">Activate</button>\n      </div>\n    </div>\n  </div>`);\n\n  const modal = document.getElementById('license-modal');\n  const codeInput = document.getElementById('license-code-input');\n  const activateBtn = document.getElementById('license-activate');\n  const deactivateBtn = document.getElementById('license-deactivate');\n  const errorEl = document.getElementById('license-error');\n  const successEl = document.getElementById('license-success');\n  const badgeIcon = document.getElementById('license-badge-icon');\n  const badgeText = document.getElementById('license-badge-text');\n  const badge = document.getElementById('license-badge');\n  const detailsEl = document.getElementById('license-details');\n  const featureList = document.getElementById('license-feature-list');\n  const activateSection = document.getElementById('license-activate-section');\n\n  let currentStatus = null;\n\n  function hideMessages() {\n    errorEl.style.display = 'none';\n    successEl.style.display = 'none';\n  }\n\n  function showError(msg) {\n    hideMessages();\n    errorEl.textContent = msg;\n    errorEl.style.display = 'block';\n  }\n\n  function showSuccess(msg) {\n    hideMessages();\n    successEl.textContent = msg;\n    successEl.style.display = 'block';\n  }\n\n  function renderStatus(status) {\n    currentStatus = status;\n\n    if (status.active) {\n      badge.style.background = 'rgba(46,204,113,0.15)';\n      badge.style.color = 'var(--ok-fg)';\n      badgeIcon.textContent = '\\u2605';\n      badgeText.textContent = 'Premium Active';\n      const expiryLine = status.lifetime\n        ? '<div>License: <strong>LIFETIME</strong></div>'\n        : `<div>Expires: <strong>${new Date(status.expiresAt).toLocaleDateString()}</strong> (${status.daysRemaining} days remaining)</div>`;\n      detailsEl.innerHTML = `\n        <div>Code: <code style=\"font-family: monospace;\">${status.code || '***'}</code></div>\n        ${expiryLine}\n      `;\n      activateSection.style.display = 'none';\n      activateBtn.style.display = 'none';\n      deactivateBtn.style.display = '';\n    } else {\n      badge.style.background = 'rgba(149,165,166,0.15)';\n      badge.style.color = 'var(--muted)';\n      badgeIcon.textContent = '\\u2606';\n      badgeText.textContent = status.expired ? 'License Expired' : 'Free Tier';\n      detailsEl.innerHTML = status.expired\n        ? '<div>Your license has expired. Enter a new code to renew.</div>'\n        : '<div>Enter a license code to unlock premium features.</div>';\n      activateSection.style.display = '';\n      activateBtn.style.display = '';\n      deactivateBtn.style.display = 'none';\n    }\n\n    // Render feature list\n    const features = status.premiumFeatures || {};\n    const activeFeatures = new Set(status.features || []);\n    featureList.innerHTML = Object.entries(features).map(([key, info]) => {\n      const active = activeFeatures.has(key);\n      return `<div style=\"display: flex; align-items: center; gap: 8px; padding: 8px 12px; border-radius: 6px; background: var(--card-bg); border: 1px solid var(--border);\">\n        <span style=\"font-size: 1.1rem;\">${active ? '\\u2705' : '\\uD83D\\uDD12'}</span>\n        <div>\n          <div style=\"font-weight: 600; font-size: 0.9rem;\">${info.name}</div>\n          <div style=\"font-size: 0.78rem; color: var(--muted);\">${info.description}</div>\n        </div>\n      </div>`;\n    }).join('');\n  }\n\n  async function loadStatus() {\n    try {\n      const resp = await fetch('/api/v1/license/status');\n      const data = await resp.json();\n      if (data.success) {\n        renderStatus(data.license);\n        updateHeaderBadge(data.license);\n      }\n    } catch (e) {\n      console.warn('Failed to load license status:', e.message);\n    }\n  }\n\n  async function activateLicense() {\n    const code = codeInput.value.trim();\n    if (!code) {\n      showError('Please enter a license code.');\n      return;\n    }\n\n    hideMessages();\n    activateBtn.disabled = true;\n    activateBtn.textContent = 'Activating...';\n\n    try {\n      const resp = await secureFetch('/api/v1/license/activate', {\n        method: 'POST',\n        headers: { 'Content-Type': 'application/json' },\n        body: JSON.stringify({ code })\n      });\n      const data = await resp.json();\n\n      if (data.success) {\n        showSuccess(data.message);\n        codeInput.value = '';\n        renderStatus(data.license);\n        showNotification('License activated! Premium features unlocked.', 'success', 5000);\n        updateHeaderBadge(data.license);\n      } else {\n        showError(data.error || 'Activation failed');\n      }\n    } catch (e) {\n      showError('Network error: ' + e.message);\n    } finally {\n      activateBtn.disabled = false;\n      activateBtn.textContent = 'Activate';\n    }\n  }\n\n  async function deactivateLicense() {\n    if (!confirm('Deactivate your license? You can reuse the code on another machine.')) return;\n\n    deactivateBtn.disabled = true;\n    deactivateBtn.textContent = 'Deactivating...';\n\n    try {\n      const resp = await secureFetch('/api/v1/license/deactivate', { method: 'POST' });\n      const data = await resp.json();\n\n      if (data.success) {\n        showSuccess(data.message);\n        await loadStatus();\n        showNotification('License deactivated.', 'info', 3000);\n        updateHeaderBadge({ active: false });\n      } else {\n        showError(data.error || 'Deactivation failed');\n      }\n    } catch (e) {\n      showError('Network error: ' + e.message);\n    } finally {\n      deactivateBtn.disabled = false;\n      deactivateBtn.textContent = 'Deactivate';\n    }\n  }\n\n  function updateHeaderBadge(status) {\n    const topbar = document.getElementById('license-status-topbar');\n    const iconEl = document.getElementById('license-topbar-icon');\n    const textEl = document.getElementById('license-topbar-text');\n    const timeEl = document.getElementById('license-topbar-time');\n    if (!topbar) return;\n\n    topbar.className = 'license-status-topbar ' + (status.active ? 'premium' : 'free');\n\n    if (status.active) {\n      iconEl.textContent = '\\u2605';\n      textEl.textContent = 'PREMIUM';\n      if (status.lifetime) {\n        timeEl.textContent = '\\u00b7 LIFETIME';\n      } else {\n        const days = status.daysRemaining;\n        timeEl.textContent = days != null ? '\\u00b7 ' + days + 'd remaining' : '';\n      }\n    } else {\n      iconEl.textContent = '\\u2606';\n      textEl.textContent = status.expired ? 'EXPIRED' : 'FREE TIER';\n      timeEl.textContent = '';\n    }\n  }\n\n  function openLicenseModal() {\n    hideMessages();\n    loadStatus();\n    modal.classList.add('show');\n  }\n\n  // Format code input as user types (auto-add dashes)\n  codeInput.addEventListener('input', function() {\n    let val = this.value.toUpperCase().replace(/[^A-Z0-9-]/g, '');\n    // Don't auto-format if user is deleting\n    if (val.length > this._prevLength) {\n      val = val.replace(/-/g, '');\n      if (val.length > 2 && !val.startsWith('DC')) {\n        val = 'DC' + val;\n      }\n      // Add dashes after DC and every 5 chars\n      if (val.startsWith('DC') && val.length > 2) {\n        const parts = ['DC'];\n        const rest = val.substring(2);\n        for (let i = 0; i < rest.length; i += 5) {\n          parts.push(rest.substring(i, i + 5));\n        }\n        val = parts.join('-');\n      }\n    }\n    this._prevLength = val.length;\n    this.value = val;\n  });\n\n  // Wire up events\n  activateBtn.addEventListener('click', activateLicense);\n  deactivateBtn.addEventListener('click', deactivateLicense);\n  codeInput.addEventListener('keydown', (e) => {\n    if (e.key === 'Enter') activateLicense();\n  });\n  wireModal(modal, document.getElementById('license-cancel'));\n  const topbarEl = document.getElementById('license-status-topbar');\n  if (topbarEl) topbarEl.addEventListener('click', () => window.openLicenseModal && window.openLicenseModal());\n\n  // Expose for other modules to open\n  window.openLicenseModal = openLicenseModal;\n\n  // Expose feature check for frontend gating\n  window.checkPremiumFeature = async function(feature) {\n    try {\n      const resp = await fetch(`/api/v1/license/feature/${feature}`);\n      const data = await resp.json();\n      return data.available;\n    } catch {\n      return false;\n    }\n  };\n\n  // Load status on page load\n  loadStatus().then(status => {\n    if (currentStatus) updateHeaderBadge(currentStatus);\n  });\n})();\n;\n// Share Modal \u2014 DC-058\n//\n// Admin UI for DC-053 share routes. Opened from the \"Share\" button on each\n// service card (added in core/grid.js next to the existing options/delete\n// buttons). Two tabs:\n//   - Public link: pick a TTL (1h/24h/7d), POST /api/v1/share, render the\n//     returned urlPath with a copy button + revoke control.\n//   - Tailscale invite: enter an email, POST /api/v1/share/tailscale, render\n//     delivered status (inbox vs dev-console fallback vs URL fallback).\n//\n// Modal also lists outstanding shares for the selected service (GET /api/v1/share)\n// with revoke buttons. The list refreshes after every issue/revoke.\n//\n// Both issue endpoints are Pro-gated on the server \u2014 the modal surfaces a 402\n// as an upgrade prompt (\"Share is a Pro feature. Activate a license to unlock.\").\n// Tailscale invites additionally require tailscaleCoord configured on the host;\n// the server returns 400 with a clear message when missing.\n\n(function() {\n  'use strict';\n\n  if (window.__dc_058_share_modal_loaded) return;\n  window.__dc_058_share_modal_loaded = true;\n\n  const TTL_OPTIONS = [\n    { ms: 60 * 60 * 1000, label: '1 hour' },\n    { ms: 24 * 60 * 60 * 1000, label: '24 hours' },\n    { ms: 7 * 24 * 60 * 60 * 1000, label: '7 days' },\n  ];\n\n  injectModal('share-modal', `\n    <div id=\"share-modal\" class=\"weather-modal\" role=\"dialog\" aria-labelledby=\"share-modal-title\">\n      <div class=\"weather-modal-content\" style=\"min-width: 460px; max-width: 580px;\">\n        <h3 id=\"share-modal-title\">Share <span id=\"share-modal-service-name\">\u2026</span></h3>\n        <p style=\"font-size: 0.85rem; color: var(--muted); margin: 0 0 16px;\">\n          Create a public link or Tailscale invite so someone outside your network can access this service.\n        </p>\n\n        <div class=\"share-tabs\" style=\"display: flex; gap: 4px; margin-bottom: 16px; border-bottom: 1px solid var(--border);\">\n          <button class=\"share-tab active\" data-tab=\"public\" type=\"button\"\n            style=\"background: transparent; border: 0; border-bottom: 2px solid var(--accent); padding: 8px 14px; color: var(--fg); font-weight: 600; cursor: pointer;\">\n            Public link\n          </button>\n          <button class=\"share-tab\" data-tab=\"tailscale\" type=\"button\"\n            style=\"background: transparent; border: 0; border-bottom: 2px solid transparent; padding: 8px 14px; color: var(--muted); cursor: pointer;\">\n            Tailscale invite\n          </button>\n        </div>\n\n        <div class=\"share-tab-panel\" data-panel=\"public\">\n          <label class=\"form-label-bold\" for=\"share-public-ttl\">Link duration:</label>\n          <select id=\"share-public-ttl\" style=\"width: 100%; padding: 8px 10px; margin: 6px 0 12px; background: var(--input-bg); color: var(--fg); border: 1px solid var(--border); border-radius: 4px;\">\n            ${TTL_OPTIONS.map(o => `<option value=\"${o.ms}\">${o.label}</option>`).join('')}\n          </select>\n          <button id=\"share-public-create\" class=\"btn-accent\" type=\"button\"\n            style=\"width: 100%; padding: 10px; background: var(--accent); color: #04141f; border: 0; border-radius: 4px; font-weight: 600; cursor: pointer;\">\n            Create share link\n          </button>\n        </div>\n\n        <div class=\"share-tab-panel\" data-panel=\"tailscale\" style=\"display: none;\">\n          <label class=\"form-label-bold\" for=\"share-ts-email\">Recipient email:</label>\n          <input id=\"share-ts-email\" type=\"email\" placeholder=\"alice@example.com\" autocomplete=\"off\"\n            style=\"width: 100%; padding: 10px 12px; margin: 6px 0 12px; background: var(--card-bg); color: var(--fg); border: 1px solid var(--border); border-radius: 4px; font-size: 0.95rem;\" />\n          <p style=\"font-size: 0.8rem; color: var(--muted); margin: 0 0 12px;\">\n            A single-use Tailscale pre-auth key is generated and emailed. The device joins your tailnet and is routed to this service via Caddy.\n          </p>\n          <button id=\"share-ts-create\" class=\"btn-accent\" type=\"button\"\n            style=\"width: 100%; padding: 10px; background: var(--accent); color: #04141f; border: 0; border-radius: 4px; font-weight: 600; cursor: pointer;\">\n            Create Tailscale invite\n          </button>\n        </div>\n\n        <div id=\"share-issued\" style=\"display: none; margin-top: 16px; padding: 12px; background: var(--card-bg); border: 1px solid var(--border); border-radius: 6px;\">\n          <div style=\"font-size: 0.8rem; color: var(--muted); margin-bottom: 6px;\">Share link:</div>\n          <div style=\"display: flex; gap: 6px; align-items: center;\">\n            <input id=\"share-issued-url\" type=\"text\" readonly\n              style=\"flex: 1; padding: 8px 10px; background: var(--bg); color: var(--fg); border: 1px solid var(--border); border-radius: 4px; font-family: monospace; font-size: 0.85rem;\" />\n            <button id=\"share-issued-copy\" type=\"button\"\n              style=\"padding: 8px 14px; background: var(--accent); color: #04141f; border: 0; border-radius: 4px; font-weight: 600; cursor: pointer;\">\n              Copy\n            </button>\n          </div>\n          <div id=\"share-issued-meta\" style=\"font-size: 0.8rem; color: var(--muted); margin-top: 8px;\"></div>\n        </div>\n\n        <div id=\"share-error\" style=\"display: none; margin-top: 12px; padding: 10px; border-radius: 4px; background: rgba(231,76,60,0.15); color: var(--bad-fg); font-size: 0.85rem;\"></div>\n        <div id=\"share-success\" style=\"display: none; margin-top: 12px; padding: 10px; border-radius: 4px; background: rgba(46,204,113,0.15); color: var(--ok-fg); font-size: 0.85rem;\"></div>\n\n        <div id=\"share-outstanding\" style=\"margin-top: 16px;\">\n          <label class=\"form-label-bold\">Outstanding shares for this service</label>\n          <div id=\"share-outstanding-list\" style=\"margin-top: 6px; font-size: 0.85rem;\"></div>\n        </div>\n\n        <div class=\"weather-modal-buttons\" style=\"margin-top: 18px;\">\n          <button id=\"share-cancel\" type=\"button\">Close</button>\n        </div>\n      </div>\n    </div>\n  `);\n\n  const modal = document.getElementById('share-modal');\n  const serviceNameEl = document.getElementById('share-modal-service-name');\n  const issuedEl = document.getElementById('share-issued');\n  const issuedUrlInput = document.getElementById('share-issued-url');\n  const issuedCopyBtn = document.getElementById('share-issued-copy');\n  const issuedMetaEl = document.getElementById('share-issued-meta');\n  const errorEl = document.getElementById('share-error');\n  const successEl = document.getElementById('share-success');\n  const outstandingListEl = document.getElementById('share-outstanding-list');\n  const cancelBtn = document.getElementById('share-cancel');\n  const publicCreateBtn = document.getElementById('share-public-create');\n  const tsCreateBtn = document.getElementById('share-ts-create');\n  const tsEmailInput = document.getElementById('share-ts-email');\n  const publicTtlSelect = document.getElementById('share-public-ttl');\n\n  let currentService = null; // { id, name }\n  let activeTab = 'public';\n\n  function hideMessages() {\n    errorEl.style.display = 'none';\n    successEl.style.display = 'none';\n    issuedEl.style.display = 'none';\n  }\n\n  function showError(msg) {\n    successEl.style.display = 'none';\n    issuedEl.style.display = 'none';\n    errorEl.textContent = msg;\n    errorEl.style.display = 'block';\n  }\n\n  function showSuccess(msg) {\n    errorEl.style.display = 'none';\n    successEl.textContent = msg;\n    successEl.style.display = 'block';\n  }\n\n  function _originFromPage() {\n    // Build the absolute share URL from the page's current origin so the\n    // link is correct regardless of whether the user is on http://localhost\n    // (dev) or https://status.sami (prod). The urlPath returned by the API\n    // is a path-only string starting with /share/.\n    return window.location.origin;\n  }\n\n  function _absUrl(urlPath) {\n    if (urlPath.startsWith('http')) return urlPath;\n    return _originFromPage() + urlPath;\n  }\n\n  function _formatExpiry(iso) {\n    if (!iso) return '';\n    const d = new Date(iso);\n    if (Number.isNaN(d.getTime())) return '';\n    return d.toLocaleString();\n  }\n\n  function _formatRemaining(ms) {\n    if (ms <= 0) return 'expired';\n    const h = Math.floor(ms / 3600000);\n    if (h >= 24) return `${Math.floor(h / 24)}d ${h % 24}h left`;\n    const m = Math.floor((ms % 3600000) / 60000);\n    return `${h}h ${m}m left`;\n  }\n\n  function setActiveTab(name) {\n    activeTab = name;\n    hideMessages();\n    modal.querySelectorAll('.share-tab').forEach(btn => {\n      const isActive = btn.dataset.tab === name;\n      btn.classList.toggle('active', isActive);\n      btn.style.borderBottomColor = isActive ? 'var(--accent)' : 'transparent';\n      btn.style.color = isActive ? 'var(--fg)' : 'var(--muted)';\n      btn.style.fontWeight = isActive ? '600' : '400';\n    });\n    modal.querySelectorAll('.share-tab-panel').forEach(p => {\n      p.style.display = p.dataset.panel === name ? '' : 'none';\n    });\n  }\n\n  async function loadOutstanding() {\n    outstandingListEl.innerHTML = '<span style=\"color: var(--muted);\">Loading\u2026</span>';\n    try {\n      const resp = await fetch('/api/v1/share', { credentials: 'same-origin' });\n      if (!resp.ok) {\n        outstandingListEl.innerHTML = '<span style=\"color: var(--muted);\">No shares listed.</span>';\n        return;\n      }\n      const body = await resp.json();\n      const list = (body && body.data) || [];\n      const filtered = list.filter(s => s.serviceId === currentService.id);\n      if (filtered.length === 0) {\n        outstandingListEl.innerHTML = '<span style=\"color: var(--muted);\">No outstanding shares for this service.</span>';\n        return;\n      }\n      outstandingListEl.innerHTML = filtered.map(s => {\n        const remaining = s.expiresAt ? _formatRemaining(new Date(s.expiresAt).getTime() - Date.now()) : '';\n        return `\n          <div class=\"share-row\" data-share-id=\"${escapeHtml(s.id)}\"\n            style=\"display: flex; align-items: center; gap: 8px; padding: 6px 0; border-bottom: 1px dashed var(--border);\">\n            <span style=\"flex: 1;\">\n              <strong>${s.kind === 'tailscale' ? 'Tailscale' : 'Public'}</strong>\n              <span style=\"color: var(--muted);\"> \u00B7 expires ${escapeHtml(_formatExpiry(s.expiresAt))} (${remaining})</span>\n            </span>\n            <button class=\"share-revoke\" data-share-id=\"${escapeHtml(s.id)}\" type=\"button\"\n              style=\"padding: 4px 10px; background: transparent; color: var(--bad-fg); border: 1px solid var(--bad-fg); border-radius: 4px; cursor: pointer; font-size: 0.8rem;\">\n              Revoke\n            </button>\n          </div>\n        `;\n      }).join('');\n      outstandingListEl.querySelectorAll('.share-revoke').forEach(btn => {\n        btn.addEventListener('click', () => revokeShare(btn.dataset.shareId));\n      });\n    } catch (e) {\n      outstandingListEl.innerHTML = '<span style=\"color: var(--muted);\">Could not load outstanding shares.</span>';\n    }\n  }\n\n  async function revokeShare(id) {\n    try {\n      const resp = await fetch(`/api/v1/share/${encodeURIComponent(id)}`, {\n        method: 'DELETE',\n        credentials: 'same-origin',\n      });\n      if (!resp.ok) {\n        const body = await resp.json().catch(() => ({}));\n        showError(body && body.error || `Revoke failed (HTTP ${resp.status}).`);\n        return;\n      }\n      showSuccess('Share revoked.');\n      loadOutstanding();\n    } catch (e) {\n      showError('Network error while revoking.');\n    }\n  }\n\n  async function issuePublic() {\n    if (!currentService) return;\n    hideMessages();\n    publicCreateBtn.disabled = true;\n    const original = publicCreateBtn.textContent;\n    publicCreateBtn.textContent = 'Creating\u2026';\n    try {\n      const ttlMs = parseInt(publicTtlSelect.value, 10);\n      const resp = await fetch('/api/v1/share', {\n        method: 'POST',\n        credentials: 'same-origin',\n        headers: { 'Content-Type': 'application/json' },\n        body: JSON.stringify({ serviceId: currentService.id, ttlMs }),\n      });\n      const body = await resp.json().catch(() => ({}));\n      if (!resp.ok || !body.success) {\n        _renderApiError(resp.status, body);\n        return;\n      }\n      const urlPath = body.data.urlPath;\n      issuedUrlInput.value = _absUrl(urlPath);\n      issuedMetaEl.textContent = `Public link \u00B7 expires ${_formatExpiry(body.data.expiresAt)}`;\n      issuedEl.style.display = 'block';\n      showSuccess('Share link created.');\n      loadOutstanding();\n    } catch (e) {\n      showError('Network error while creating share.');\n    } finally {\n      publicCreateBtn.disabled = false;\n      publicCreateBtn.textContent = original;\n    }\n  }\n\n  async function issueTailscale() {\n    if (!currentService) return;\n    const email = (tsEmailInput.value || '').trim();\n    if (!email || !email.includes('@')) {\n      showError('A valid recipient email is required.');\n      return;\n    }\n    hideMessages();\n    tsCreateBtn.disabled = true;\n    const original = tsCreateBtn.textContent;\n    tsCreateBtn.textContent = 'Creating\u2026';\n    try {\n      const resp = await fetch('/api/v1/share/tailscale', {\n        method: 'POST',\n        credentials: 'same-origin',\n        headers: { 'Content-Type': 'application/json' },\n        body: JSON.stringify({ serviceId: currentService.id, email }),\n      });\n      const body = await resp.json().catch(() => ({}));\n      if (!resp.ok || !body.success) {\n        _renderApiError(resp.status, body);\n        return;\n      }\n      // Tailscale shares show the raw urlPath (which is the share URL) if\n      // email delivery failed. The share itself is one-shot so the admin\n      // can manually paste the link into a chat if SMTP failed.\n      const fallback = body.data && body.data.urlPath;\n      if (fallback) {\n        issuedUrlInput.value = _absUrl(fallback);\n        issuedMetaEl.textContent = `Tailscale invite \u00B7 emailed to ${email} (or use this URL manually if delivery failed).`;\n      } else {\n        issuedUrlInput.value = '';\n        issuedMetaEl.textContent = `Tailscale invite sent to ${email}.`;\n      }\n      issuedEl.style.display = 'block';\n      showSuccess('Tailscale invite created.');\n      tsEmailInput.value = '';\n      loadOutstanding();\n    } catch (e) {\n      showError('Network error while creating Tailscale invite.');\n    } finally {\n      tsCreateBtn.disabled = false;\n      tsCreateBtn.textContent = original;\n    }\n  }\n\n  function _renderApiError(status, body) {\n    const err = (body && body.error) || '';\n    if (status === 402) {\n      showError('Share is a Pro feature. Activate a license to unlock.');\n      return;\n    }\n    if (status === 400 && /tailscale/i.test(err)) {\n      showError('Tailscale is not configured on this host. Set up Tailscale in the dashboard first.');\n      return;\n    }\n    if (status === 403) {\n      showError('You do not have permission to share services.');\n      return;\n    }\n    if (status === 404) {\n      showError('Service not found. It may have been deleted.');\n      return;\n    }\n    showError(err || `Request failed (HTTP ${status}).`);\n  }\n\n  function openShareModal(service) {\n    if (!service || !service.id) return;\n    currentService = { id: service.id, name: service.name || service.id };\n    serviceNameEl.textContent = currentService.name;\n    hideMessages();\n    setActiveTab('public');\n    tsEmailInput.value = '';\n    publicTtlSelect.value = String(TTL_OPTIONS[1].ms); // 24h default\n    modal.classList.add('show');\n    loadOutstanding();\n  }\n\n  // Wire events\n  modal.querySelectorAll('.share-tab').forEach(btn => {\n    btn.addEventListener('click', () => setActiveTab(btn.dataset.tab));\n  });\n  publicCreateBtn.addEventListener('click', issuePublic);\n  tsCreateBtn.addEventListener('click', issueTailscale);\n  cancelBtn.addEventListener('click', () => modal.classList.remove('show'));\n  wireModal(modal, cancelBtn);\n\n  // Copy-to-clipboard for the issued share URL\n  issuedCopyBtn.addEventListener('click', async () => {\n    const url = issuedUrlInput.value;\n    if (!url) return;\n    try {\n      if (navigator.clipboard && navigator.clipboard.writeText) {\n        await navigator.clipboard.writeText(url);\n      } else {\n        // Fallback for older browsers / unsafe contexts\n        issuedUrlInput.select();\n        document.execCommand('copy');\n      }\n      const original = issuedCopyBtn.textContent;\n      issuedCopyBtn.textContent = 'Copied!';\n      setTimeout(() => { issuedCopyBtn.textContent = original; }, 1200);\n    } catch (e) {\n      showError('Could not copy to clipboard. Select the URL manually.');\n    }\n  });\n\n  // Expose for other modules to open\n  window.openShareModal = openShareModal;\n})();\n"],
  "mappings": "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",
  "names": ["logoModal", "previewDark", "previewLight", "logoStatus", "sameBothCheckbox", "dualUploads", "singleUpload", "uploadDark", "uploadLight", "uploadSingle", "brandLogoDark", "brandLogoLight", "topRow", "dashboardTitleInput", "DEFAULT_TITLE", "pendingDarkData", "pendingLightData", "pendingSingleData", "currentPosition", "currentTitle", "readFileAsDataURL", "file", "callback", "reader", "e", "data", "applyLogoPosition", "pos", "btn", "applyDashboardTitle", "title", "headerTitle", "loadCustomLogo", "response", "error", "isCustom", "newTitle", "payload", "t", "faviconLink", "faviconPreview", "faviconStatus", "pendingFaviconData", "faviconUpload", "loadCustomFavicon", "event", "settingsTzSelect", "currentTz", "res", "tz", "cfg", "selectEl", "selectedTz", "timezones", "detected", "opt", "currentConfigType", "serverConfig", "checkServerConfig", "setupTzSelect", "showStep", "stepId", "step", "targetStep", "showSummary", "summaryContent", "html", "tld", "caName", "dnsIP", "dnsPort", "ip", "domain", "email", "routingMode", "exampleUrls", "saveConfigToServer", "config", "finishSetup", "selectedProvider", "savedToServer", "configName", "saveLocation", "step1Next", "selected", "skipBtn", "tldInput", "preview1", "preview2", "homelabBack", "homelabNext", "simpleBack", "simpleNext", "radio", "note", "publicBack", "publicNext", "summaryBack", "summaryNext", "diskSafetyBack", "finishBtn", "configStr", "errorHandler", "APPS_KEY", "apiTemplates", "apiCategories", "modal", "grid", "fetchAppTemplates", "checkPortAvailability", "port", "getSuggestedPort", "basePort", "buildAppSelector", "byCategory", "appId", "template", "category", "categoryOrder", "apps", "a", "b", "header", "categoryInfo", "app", "option", "isWidget", "widgetEnabled", "widgetBadge", "difficultyBadge", "toggleDashboardWidget", "showDeployConfig", "optionEl", "key", "newState", "selector", "el", "badge", "appTemplate", "deployModal", "subdomainInput", "urlPreview", "ipInput", "portInput", "tailscaleCheckbox", "tailscaleStatus", "checkResult", "container", "defaultSubdomain", "subpathWarning", "support", "cfgDnsType", "cfgSslType", "dnsRadio", "sslRadio", "dnsSection", "advancedDetails", "advancedContent", "dnsSectionEl", "sslSectionEl", "mediaPathSection", "mediaPathInput", "mediaPathDescription", "detectedMountsContainer", "detectedMountsList", "mountsResult", "autoPaths", "m", "mount", "isSelected", "currentPaths", "p", "idx", "plexClaimSection", "volumeSection", "volumeList", "mediaContainerPath", "nonMediaVolumes", "v", "vol", "i", "hostDefault", "containerPath", "row", "input", "defaultPort", "portStatus", "checkAndUpdatePortStatus", "portToCheck", "result", "suggestedPort", "useBtn", "portCheckTimeout", "updateUrlPreview", "subdomain", "dnsType", "sslType", "url", "protocol", "addAppToGrid", "deployConfig", "customApps", "usingExisting", "existingApp", "index", "portToUse", "portCheck", "apiDeployConfig", "catalogPayload", "newApp", "message", "checkSSLCertificate", "instructions", "appName", "attempts", "maxAttempts", "checkCert", "loadCustomApps", "templateId", "entry", "id", "mediaPath", "customVolumes", "folderBrowserModal", "folderBrowserPath", "folderBrowserList", "folderBrowserSelected", "folderBrowserSelectedList", "currentBrowserPath", "selectedFolders", "targetMediaInput", "mediaInput", "updateSelectedFoldersDisplay", "loadFolderContents", "path", "item", "icon", "selectedStyle", "recipeTemplates", "recipeCategories", "currentRecipe", "currentStep", "isPremium", "cancelBtn", "prevBtn", "nextBtn", "fetchRecipeTemplates", "resp", "checkRecipePremium", "recipes", "getPreviewRecipes", "recipeList", "recipe", "componentBadge", "lockOverlay", "openRecipeDeployWizard", "appSelectorModal", "updateStepUI", "renderStep1", "panel", "list", "components", "comp", "isRequired", "isInternal", "renderStep2", "sharedVolumes", "renderStep3", "content", "selectedComponents", "getSelectedComponents", "volumeInputs", "volumes", "tailscale", "c", "k", "checkboxes", "selectedIds", "cb", "executeDeploy", "progressList", "resultEl", "updateProgressItem", "deployed", "err", "s", "componentId", "status", "text", "statusEl", "cards", "groups", "card", "recipeId", "groupCards", "label", "action", "endpoint", "method", "r", "style", "button", "originalText", "viewBtn", "refreshBtn", "clearBtn", "closeBtn", "levelSel", "contextSel", "searchInput", "sinceInput", "untilInput", "loadMoreBtn", "totalSpan", "PAGE_SIZE", "currentOffset", "inflight", "filterNonce", "knownContexts", "toIso", "localDtValue", "d", "refreshContexts", "currentValue", "buildQuery", "params", "since", "until", "search", "loadLogs", "append", "myNonce", "logs", "reason", "log", "level", "levelColor", "ts", "ctx", "msg", "table", "detail", "clearLogs", "searchDebounce", "wireFilters", "dateDebounce", "containerSelect", "logContent", "logSearch", "logTail", "streamBtn", "downloadBtn", "clearSearchBtn", "closeBtn2", "streamStatus", "streamIndicator", "streamText", "lineCount", "filterCount", "imageEl", "createdEl", "currentContainerId", "currentLogs", "filteredLogs", "eventSource", "isStreaming", "searchTimeout", "formatDate", "dateStr", "escapeHtml", "str", "div", "formatLogEntry", "streamClass", "streamIcon", "renderLogs", "searchTerm", "loadContainers", "containers", "currentVal", "loadContainerInfo", "containerId", "stopStream", "tail", "startStream", "entryDiv", "downloadLogs", "containerName", "timestamp", "filename", "stream", "blob", "closeModal", "UNIT_PRESETS", "unitSelect", "tailInput", "clearSearch", "overflowHint", "unitDisplay", "streamState", "available", "lines", "streaming", "searchTimer", "setAvailable", "isAvailable", "probeAvailable", "renderLines", "term", "filtered", "l", "line", "loadTail", "unit", "ev", "close", "openJournaldModal", "openBtn", "detailsDiv", "createBtn", "createStatus", "showContainerDetails", "createSnapshot", "name", "leaveRunning", "openModal", "tab", "connectBtn", "phaseDetect", "phaseCredentials", "phaseProgress", "phaseResults", "detectResults", "credentialInputs", "progressSteps", "resultsContent", "plexLibraries", "retryBtn", "detectedData", "serviceIcons", "serviceLabels", "showPhase", "phase", "statusBadge", "colors", "smartDetect", "svc", "info", "source", "version", "keySaved", "buildCredentialInputs", "services", "arrServices", "isConnected", "plex", "plexConnected", "seerr", "seerrOk", "configuredHtml", "cs", "service", "urlInput", "keyInput", "statusSpan", "apiKey", "smartConnect", "stepsHtml", "detailColor", "showResults", "allGood", "headerColor", "headerIcon", "headerText", "st", "fetchPlexLibraries", "lib", "typeIcon", "saveBtn", "provider", "checkbox", "healthCheckEnabled", "healthCheckConfig", "loadNotificationConfig", "emailPassEl", "loadNotificationHistory", "date", "saveNotificationConfig", "testProvider", "loadNotificationStatus", "lastSentEl", "panelId", "tabBar", "modalContent", "target", "BROWSER_STATE_KEYS", "collectBrowserState", "state", "val", "j", "restoreBrowserState", "browserState", "count", "isLegacyFormat", "restoreLegacyFormat", "slug", "exportBtn", "selectFileBtn", "fileInput", "fileNameDiv", "previewDiv", "previewContent", "restoreBtn", "resultDiv", "scheduleContainer", "historyContainer", "diskContainer", "pointintimeContainer", "selectedBackup", "stateCount", "themeCount", "backup", "preview", "reloadCaddy", "browserCount", "loadSchedulesTab", "schedules", "sch", "nextRunStr", "lastRunStr", "toggle", "updateSchedule", "sel", "inp", "runBackupNow", "deleteSchedule", "addNewSchedule", "updates", "interval", "retention", "appIdInput", "loadDiskBackups", "files", "byApp", "f", "appIds", "appFiles", "compareBackupFile", "restoreBackupFile", "loadBackupHistory", "bk", "sizeMB", "backupId", "loadPointInTimeTab", "licenseRes", "licenseData", "servicesRes", "servicesData", "loadPointInTimeBackups", "listEl", "diff", "svcChanged", "cfgChanged", "autoRefreshCheckbox", "aggregatedContainer", "alertsContainer", "lastUpdateSpan", "refreshInterval", "cachedMonitoringData", "formatBytes", "bytes", "sizes", "getCpuColor", "percent", "getMemColor", "loadStats", "stats", "isNewApi", "cur", "cpu", "mem", "cpuColor", "memColor", "memUsed", "memLimit", "netRx", "netTx", "agg", "loadAggregated", "loadAlerts", "alertHistory", "hd", "allConfigs", "cd", "containerRows", "historyRows", "time", "notifiedMark", "configSection", "configs", "cId", "stopAutoRefresh", "orig", "startAutoRefresh", "historyContainerSelect", "historyArea", "rangeButtons", "currentRange", "rangeToMs", "range", "tierLabel", "tier", "renderSparkline", "samples", "accessor", "color", "values", "max", "min", "w", "h", "pad", "stepX", "points", "x", "y", "last", "avg", "populateHistoryContainerSelect", "previous", "entries", "loadHistory", "endTime", "startTime", "isRaw", "cpuAccessor", "memAccessor", "netRxAccessor", "netTxAccessor", "statusContainer", "incidentsContainer", "configContainer", "addBtn", "formEl", "formTitle", "formCancel", "formSave", "HEALTH_SETTINGS_KEY", "HEALTH_DEFAULTS", "globalSaveBtn", "globalResetBtn", "globalStatusSpan", "retentionInput", "intervalInput", "statsIntervalInput", "maxEntriesInput", "diskThresholdInput", "loadHealthSettings", "raw", "saved", "applyHealthSettingsToUI", "saveHealthSettings", "settings", "resetHealthSettings", "editingId", "uptimeColor", "pct", "severityBadge", "sev", "loadStatus", "isUp", "dotColor", "u24", "u7d", "avgRt", "lastCheck", "detailRow", "rt", "loadIncidents", "openRes", "histRes", "openData", "histData", "open", "inc", "history", "resolved", "dur", "loadConfig", "showForm", "timeout", "codes", "sla", "slow", "hideForm", "body", "checkBtn", "availableContainer", "autoContainer", "lastCheckSpan", "loadAvailable", "u", "countBadge", "updateAllBtn", "updateAllContainers", "success", "failed", "checkForUpdates", "ok", "loadAutoConfig", "containersRes", "configRes", "containersData", "configData", "savedConfig", "cid", "scheduleVal", "rollbackVal", "windowVal", "lastRun", "schedule", "rollback", "window", "dcVersionInfo", "dcUpdateBadge", "dcUpdateDetails", "dcNewVersion", "dcChangelog", "dcApplyBtn", "dcCheckBtn", "dcRollbackBtn", "dcStatusBar", "dcHistoryContainer", "dcLastCheck", "dcShowStatus", "type", "dcLoadVersion", "commit", "dcCheckForUpdate", "silent", "updatesBtn", "dot", "dcTab", "dcApplyUpdate", "dcLoadHistory", "stColor", "dcShowRollback", "versions", "fmtBytes", "units", "loadVolumes", "vols", "isSystem", "nameInput", "loadNetworks", "nets", "n", "driverSelect", "loadDiskUsage", "sections", "parsedData", "yamlStr", "stackName", "origText", "renderPreview", "borderColor", "parts", "progressEl", "termEl", "ws", "fitAddon", "cleanup", "openExec", "dims", "cols", "rows", "resizeHandler", "filterSelect", "outcomeSelect", "loadAudit", "outcome", "actor", "actorLabel", "role", "tag", "tabs", "panels", "allEvents", "allHosts", "sseSource", "refreshOverview", "refreshEvents", "refreshHosts", "startLiveTail", "stopLiveTail", "renderEvents", "active", "statsRes", "hostsRes", "eventsRes", "hosts", "eventsCount", "renderTopList", "items", "it", "filterSource", "filterSeverity", "filterHost", "filterActor", "debounce", "refreshHostFilter", "renderEventRow", "sevColor", "current", "registerHostPrompt", "fn", "ms", "repos", "escFn", "anonymous", "typed", "$", "loadedOnce", "esc", "api", "opts", "showOutput", "loadServices", "loadRepos", "loadJournal", "qs", "loadGiteaRepos", "hostEl", "tokEl", "anonEl", "runInstall", "repoUrl", "argsRaw", "args", "setBusy", "typedToken", "requestToken", "busy", "runDeploy", "dir", "runRollback", "runStatus", "wire", "rb", "sb", "LOCATION_KEY", "LEGACY_KEY", "GEO_CACHE_KEY", "UNIT_KEY", "getUnit", "getWeatherElements", "wmoDescriptions", "wmoIcons", "windDirs", "degToDir", "deg", "geocodeLocation", "query", "cached", "geo", "formatLocation", "fetchWeather", "location", "tempUnit", "windUnit", "code", "updateWeather", "weatherWidget", "weather", "tempSuffix", "windLabel", "locationInput", "loc", "unitRadio", "newUnit", "oldUnit", "widget", "render", "DAYS", "MONTHS", "ROMAN", "currentStyle", "lastChimeHour", "chimePlaying", "prevFlipDigits", "activeLayout", "digitalRefs", "tickTimer", "playChimes", "strike", "bell", "now", "resetRenderLayout", "ensureDigitalLayout", "renderDefault", "h24", "ampm", "refs", "renderLcd", "cls", "renderFlip", "digits", "flipCard", "digit", "renderBinary", "bit", "col", "on", "renderAnalog", "useRoman", "size", "cx", "cy", "sAngle", "mAngle", "hAngle", "labels", "angle", "ticks", "outer", "inner", "x1", "y1", "x2", "y2", "svg", "tick", "nextClassName", "scheduleNextTick", "delay", "STYLES", "styleOptionsHtml", "chimesToggle", "volumeSlider", "loadSettings", "widgetEls", "fmtWhen", "start", "allDay", "today", "day", "days", "dayLabel", "timeLabel", "fetchCalendar", "end", "renderWidget", "els", "events", "next", "renderUpcoming", "renderSources", "sources", "enable", "refresh", "formCreds", "setStatus", "calBtn", "calSettings", "calClose", "POLL", "loadInfo", "loadConnections", "keys", "createConnection", "client", "snippet", "copyText", "okMsg", "refreshCardHealth", "serviceId", "uptimeEl", "barEl", "uptime24", "dismissedUpdates", "knownUpdates", "refreshCardUpdates", "notifyNew", "prev", "upd", "updateBtn", "scheduleCardEnhancements", "origRefreshAll", "themeBeforeBuilder", "editingSlug", "advancedOverrides", "THEME_LABELS", "FIELDS", "themeBtn", "themeLabel", "getLabelFor", "userThemes", "updateLabel", "buildFieldsHTML", "grouped", "buildStartFromOptions", "modalHTML", "startSelect", "editSelect", "existingSection", "lightBgCheck", "pickers", "advancedSection", "advancedToggle", "advancedVisible", "getCurrentColors", "getBaseColors", "updateAdvancedFromDerived", "base", "derived", "hex", "loadThemeIntoPickers", "themeName", "updatePreview", "loadUserThemeIntoPickers", "theme", "muted", "badgeOk", "badgeBad", "dotOk", "dotBad", "dots", "applyColorsLive", "prop", "refreshEditDropdown", "slugs", "refreshStartFrom", "openBuilder", "customizeBtn", "oldSlug", "newSlug", "themeData", "apiColors", "slugToDelete", "fallback", "exportData", "themeColors", "themeLightBg", "codeInput", "activateBtn", "deactivateBtn", "errorEl", "successEl", "badgeIcon", "badgeText", "detailsEl", "featureList", "activateSection", "currentStatus", "hideMessages", "showError", "showSuccess", "renderStatus", "expiryLine", "features", "activeFeatures", "updateHeaderBadge", "activateLicense", "deactivateLicense", "topbar", "iconEl", "textEl", "timeEl", "openLicenseModal", "rest", "topbarEl", "feature", "TTL_OPTIONS", "o", "serviceNameEl", "issuedEl", "issuedUrlInput", "issuedCopyBtn", "issuedMetaEl", "outstandingListEl", "publicCreateBtn", "tsCreateBtn", "tsEmailInput", "publicTtlSelect", "currentService", "activeTab", "_originFromPage", "_absUrl", "urlPath", "_formatExpiry", "iso", "_formatRemaining", "setActiveTab", "isActive", "loadOutstanding", "remaining", "revokeShare", "issuePublic", "original", "ttlMs", "_renderApiError", "issueTailscale", "openShareModal"]
}

diff --git a/status/js/ai-chat.js b/status/js/ai-chat.js
index 3e7ef44..b45a238 100644
--- a/status/js/ai-chat.js
+++ b/status/js/ai-chat.js
@@ -1,7 +1,53 @@
-// AI Chat Panel — DashCaddy AI Intent Router frontend
-(function() {
-  let chatMessages = [];
-  let chatHistory = [];
+// AI Chat Panel — DashCaddy AI Intent Router frontend (DC-163)
+//
+// Fixes over the previous version:
+//  - Response parsing: the API returns a FLAT ok() envelope
+//    ({success:true, intent, response, appId, engine…}); the old code read
+//    data.data (nonexistent) so EVERY reply showed "Sorry, something went
+//    wrong". Now reads the real shape.
+//  - Suggestion chips: old inline onclick used nested double quotes —
+//    invalid JS, chips did nothing. Now data-attributes + listeners.
+//  - Deploy button: window.openAppSelector never existed; now calls
+//    window.openDeployConfigFor(id) added to app-selector.js (opens the
+//    real deploy modal, same flow as clicking the app in the catalog).
+//  - Conversation history (last turns) rides along so the LLM engine can
+//    resolve "yes" / "name it vault" / follow-ups.
+//  - Engine indicator: header shows live status from /ai/capabilities.
+//  - ⚙ Settings: configure the LLM (OpenAI-compatible baseUrl/model/key)
+//    stored server-side in the encrypted credential store; Test button
+//    proves it end-to-end. Keys never come back from the server.
+// All server/model text renders via textContent (no HTML injection).
+(function () {
+  let chatTurns = [];      // [{role, content}] — transcript for LLM context
+  let engineInfo = { engine: 'pattern', llmConfigured: false };
+
+  const SUGGESTIONS = [
+    ['Deploy Plex', 'plex'],
+    ['Stream movies', 'I want to stream movies'],
+    ['Block ads', 'Block ads on my network'],
+    ['System health', 'Is everything OK?'],
+  ];
+
+  function css() {
+    if (document.getElementById('ai-chat-css')) return;
+    const s = document.createElement('style');
+    s.id = 'ai-chat-css';
+    s.textContent = `
+      #ai-chat-panel .ai-chip { background:rgba(99,102,241,0.15); border:1px solid rgba(99,102,241,0.3); border-radius:16px; padding:4px 12px; font-size:0.78rem; cursor:pointer; color:#a5b4fc; }
+      #ai-chat-panel .ai-chip:hover { background:rgba(99,102,241,0.28); }
+      #ai-chat-panel .ai-act { display:block; margin:4px 0; border-radius:8px; padding:8px 12px; cursor:pointer; font-size:0.8rem; }
+      #ai-chat-panel .ai-act.deploy { background:rgba(34,197,94,0.12); border:1px solid rgba(34,197,94,0.3); color:#4ade80; }
+      #ai-chat-panel .ai-act.warn { background:rgba(251,191,36,0.12); border:1px solid rgba(251,191,36,0.3); color:#fbbf24; }
+      #ai-chat-panel .ai-act.blue { background:rgba(99,102,241,0.12); border:1px solid rgba(99,102,241,0.3); color:#a5b4fc; }
+      #ai-chat-panel .ai-msg-user { align-self:flex-end; background:rgba(99,102,241,0.15); border-radius:10px 10px 2px 10px; padding:10px 14px; max-width:85%; font-size:0.85rem; }
+      #ai-chat-panel .ai-msg-ai { align-self:flex-start; background:rgba(255,255,255,0.05); border-radius:10px 10px 10px 2px; padding:10px 14px; max-width:85%; font-size:0.85rem; }
+      #ai-chat-panel .ai-note { font-size:0.7rem; color:var(--text-muted,#666); padding:4px 8px; line-height:1.4; }
+      #ai-chat-panel input.ai-in { flex:1; background:var(--bg-input,#0f0f1a); border:1px solid var(--border,#333); border-radius:8px; padding:10px 14px; color:var(--text,#fff); font-size:0.88rem; outline:none; }
+    `;
+    document.head.appendChild(s);
+  }
+
+  function esc(s) { return String(s == null ? '' : s); }
 
   function createChatPanel() {
     const existing = document.getElementById('ai-chat-panel');
@@ -9,110 +55,157 @@
 
     const panel = document.createElement('div');
     panel.id = 'ai-chat-panel';
-    panel.style.cssText = `
-      position: fixed; bottom: 80px; right: 20px; width: 400px; max-width: 95vw;
-      height: 500px; max-height: 70vh; background: var(--bg-card, #1a1a2e);
-      border: 1px solid var(--border, #333); border-radius: 12px;
-      display: none; flex-direction: column; z-index: 9999;
-      box-shadow: 0 8px 32px rgba(0,0,0,0.4);
-    `;
+    panel.style.cssText = 'position: fixed; bottom: 80px; right: 20px; width: 400px; max-width: 95vw; height: 520px; max-height: 70vh; background: var(--bg-card, #1a1a2e); border: 1px solid var(--border, #333); border-radius: 12px; display: none; flex-direction: column; z-index: 9999; box-shadow: 0 8px 32px rgba(0,0,0,0.4);';
 
-    panel.innerHTML = `
-      <div style="padding: 14px 18px; border-bottom: 1px solid var(--border,#333); display: flex; align-items: center; gap: 10px;">
-        <span style="font-size: 1.3rem;">🤖</span>
-        <div style="flex:1;">
-          <div style="font-weight: 700; font-size: 0.95rem;">AI Assistant</div>
-          <div id="ai-status" style="font-size: 0.72rem; color: var(--text-muted,#666);">Pattern matching • No key needed</div>
-        </div>
-        <button onclick="document.getElementById('ai-chat-panel').style.display='none'" style="background:none;border:none;font-size:1.4rem;cursor:pointer;color:var(--text-muted,#888);">×</button>
-      </div>
-      <div id="ai-chat-messages" style="flex:1; overflow-y:auto; padding:14px; display:flex; flex-direction:column; gap:10px;">
-        <div style="background:rgba(99,102,241,0.08); border-radius:10px; padding:12px; font-size:0.85rem; color:var(--text-muted,#aaa);">
-          👋 Hi! I can help you deploy apps, diagnose issues, and manage your server. Try:
-          <div style="margin-top:8px; display:flex; flex-wrap:wrap; gap:6px;">
-            <button class="ai-suggestion" onclick="window.aiChat.send('"Deploy Plex"')" style="background:rgba(99,102,241,0.15); border:1px solid rgba(99,102,241,0.3); border-radius:16px; padding:4px 12px; font-size:0.78rem; cursor:pointer; color:#a5b4fc;">Deploy Plex</button>
-            <button class="ai-suggestion" onclick="window.aiChat.send('"I want to stream movies"')" style="background:rgba(99,102,241,0.15); border:1px solid rgba(99,102,241,0.3); border-radius:16px; padding:4px 12px; font-size:0.78rem; cursor:pointer; color:#a5b4fc;">Stream movies</button>
-            <button class="ai-suggestion" onclick="window.aiChat.send('"Block ads on my network"')" style="background:rgba(99,102,241,0.15); border:1px solid rgba(99,102,241,0.3); border-radius:16px; padding:4px 12px; font-size:0.78rem; cursor:pointer; color:#a5b4fc;">Block ads</button>
-            <button class="ai-suggestion" onclick="window.aiChat.send('"Is everything OK?')" style="background:rgba(99,102,241,0.15); border:1px solid rgba(99,102,241,0.3); border-radius:16px; padding:4px 12px; font-size:0.78rem; cursor:pointer; color:#a5b4fc;">System health</button>
-          </div>
-        </div>
-      </div>
-      <div style="padding:12px; border-top:1px solid var(--border,#333);">
-        <div style="display:flex; gap:8px;">
-          <input id="ai-chat-input" type="text" placeholder="Ask me anything..." 
-            onkeypress="if(event.key==='Enter') window.aiChat.send()"
-            style="flex:1; background:var(--bg-input,#0f0f1a); border:1px solid var(--border,#333); border-radius:8px; padding:10px 14px; color:var(--text,#fff); font-size:0.88rem; outline:none;">
-          <button onclick="window.aiChat.send()" style="background:#6366f1; border:none; border-radius:8px; padding:0 16px; color:#fff; cursor:pointer; font-weight:600;">→</button>
-        </div>
-      </div>
-    `;
+    const header = document.createElement('div');
+    header.style.cssText = 'padding: 14px 18px; border-bottom: 1px solid var(--border,#333); display: flex; align-items: center; gap: 10px;';
+    const icon = document.createElement('span');
+    icon.style.cssText = 'font-size:1.3rem;';
+    icon.textContent = '🤖';
+    const titles = document.createElement('div');
+    titles.style.cssText = 'flex:1;';
+    const t1 = document.createElement('div');
+    t1.style.cssText = 'font-weight: 700; font-size: 0.95rem;';
+    t1.textContent = 'AI Assistant';
+    const t2 = document.createElement('div');
+    t2.id = 'ai-status';
+    t2.style.cssText = 'font-size: 0.72rem; color: var(--text-muted,#666);';
+    t2.textContent = 'Loading…';
+    titles.appendChild(t1); titles.appendChild(t2);
+    const gear = document.createElement('button');
+    gear.id = 'ai-settings-btn';
+    gear.style.cssText = 'background:none;border:none;font-size:1.1rem;cursor:pointer;color:var(--text-muted,#888);';
+    gear.title = 'Assistant settings';
+    gear.textContent = '⚙';
+    const close = document.createElement('button');
+    close.style.cssText = 'background:none;border:none;font-size:1.4rem;cursor:pointer;color:var(--text-muted,#888);';
+    close.title = 'Close';
+    close.textContent = '×';
+    close.addEventListener('click', () => { panel.style.display = 'none'; });
+    header.appendChild(icon); header.appendChild(titles); header.appendChild(gear); header.appendChild(close);
+
+    const messages = document.createElement('div');
+    messages.id = 'ai-chat-messages';
+    messages.style.cssText = 'flex:1; overflow-y:auto; padding:14px; display:flex; flex-direction:column; gap:10px;';
+
+    const intro = document.createElement('div');
+    intro.style.cssText = 'background:rgba(99,102,241,0.08); border-radius:10px; padding:12px; font-size:0.85rem; color:var(--text-muted,#aaa);';
+    intro.textContent = '👋 Hi! I can help you deploy apps, diagnose issues, and manage your server. Try:';
+    const chips = document.createElement('div');
+    chips.style.cssText = 'margin-top:8px; display:flex; flex-wrap:wrap; gap:6px;';
+    SUGGESTIONS.forEach(([label, text]) => {
+      const b = document.createElement('button');
+      b.className = 'ai-chip';
+      b.textContent = label;
+      b.addEventListener('click', () => send(text));
+      chips.appendChild(b);
+    });
+    intro.appendChild(chips);
+    messages.appendChild(intro);
+
+    const foot = document.createElement('div');
+    foot.style.cssText = 'padding:12px; border-top:1px solid var(--border,#333);';
+    const row = document.createElement('div');
+    row.style.cssText = 'display:flex; gap:8px;';
+    const input = document.createElement('input');
+    input.id = 'ai-chat-input';
+    input.type = 'text';
+    input.placeholder = 'Ask me anything...';
+    input.className = 'ai-in';
+    input.addEventListener('keydown', (e) => { if (e.key === 'Enter') send(); });
+    const go = document.createElement('button');
+    go.style.cssText = 'background:#6366f1; border:none; border-radius:8px; padding:0 16px; color:#fff; cursor:pointer; font-weight:600;';
+    go.textContent = '→';
+    go.addEventListener('click', () => send());
+    row.appendChild(input); row.appendChild(go);
+    foot.appendChild(row);
+
+    panel.appendChild(header); panel.appendChild(messages); panel.appendChild(foot);
     document.body.appendChild(panel);
   }
 
   function toggle() {
     let panel = document.getElementById('ai-chat-panel');
-    if (!panel) { createChatPanel(); panel = document.getElementById('ai-chat-panel'); }
+    if (!panel) { css(); createChatPanel(); panel = document.getElementById('ai-chat-panel'); refreshEngineBadge(); }
     panel.style.display = panel.style.display === 'flex' ? 'none' : 'flex';
     if (panel.style.display === 'flex') document.getElementById('ai-chat-input').focus();
   }
 
+  async function refreshEngineBadge() {
+    try {
+      const res = await fetch('/api/v1/ai/capabilities');
+      const data = await res.json();
+      if (data && data.success) {
+        engineInfo = { engine: data.engine, llmConfigured: Boolean(data.llm && data.llm.configured) };
+        const el = document.getElementById('ai-status');
+        if (el) el.textContent = engineInfo.llmConfigured
+          ? 'LLM engine: ' + (data.llm.model || 'configured')
+          : 'Pattern engine (offline) — ⚙ to add an LLM';
+      }
+    } catch (_) { /* badge stays */ }
+  }
+
   function addMessage(role, text, extra) {
     const container = document.getElementById('ai-chat-messages');
     if (!container) return;
     const div = document.createElement('div');
-    const isUser = role === 'user';
-    div.style.cssText = isUser
-      ? 'align-self:flex-end; background:rgba(99,102,241,0.15); border-radius:10px 10px 2px 10px; padding:10px 14px; max-width:85%; font-size:0.85rem;'
-      : 'align-self:flex-start; background:rgba(255,255,255,0.05); border-radius:10px 10px 10px 2px; padding:10px 14px; max-width:85%; font-size:0.85rem;';
+    div.className = role === 'user' ? 'ai-msg-user' : 'ai-msg-ai';
     div.textContent = text;
     container.appendChild(div);
+    chatTurns.push({ role: role === 'user' ? 'user' : 'assistant', content: text });
+    if (chatTurns.length > 12) chatTurns = chatTurns.slice(-12);
 
-    // Extra content (recommendations, action buttons)
     if (extra) {
       const extraDiv = document.createElement('div');
       extraDiv.style.cssText = 'align-self:flex-start; max-width:85%; margin-top:4px;';
+      if (extra.engine === 'llm-error' || extra.llmError) {
+        const n = document.createElement('div');
+        n.className = 'ai-note';
+        n.textContent = '⚠ LLM unavailable — answered with the offline pattern engine.';
+        extraDiv.appendChild(n);
+      }
       if (extra.disclaimer) {
         const disc = document.createElement('div');
-        disc.style.cssText = 'font-size:0.7rem; color:var(--text-muted,#666); padding:6px 8px; line-height:1.4; margin-top:4px;';
-        disc.textContent = '⚠️ ' + extra.disclaimer;
+        disc.className = 'ai-note';
+        disc.textContent = '⚠ ' + esc(extra.disclaimer);
         extraDiv.appendChild(disc);
       }
-      if (extra.recommendations) {
-        extra.recommendations.forEach(rec => {
+      if (Array.isArray(extra.recommendations)) {
+        extra.recommendations.forEach((rec) => {
           const btn = document.createElement('button');
-          btn.textContent = `📦 Deploy ${rec.app}`;
-          btn.style.cssText = 'display:block; margin:4px 0; background:rgba(34,197,94,0.12); border:1px solid rgba(34,197,94,0.3); border-radius:8px; padding:8px 12px; cursor:pointer; font-size:0.8rem; color:#4ade80;';
-          btn.onclick = () => window.aiChat.send('Deploy ' + rec.app);
+          btn.className = 'ai-act deploy';
+          btn.textContent = `📦 Deploy ${esc(rec.app)} — ${esc(rec.reason || '')}`;
+          btn.addEventListener('click', () => send('Deploy ' + rec.app));
           extraDiv.appendChild(btn);
         });
       }
       if (extra.appId) {
         const btn = document.createElement('button');
-        btn.textContent = `🚀 Deploy ${extra.appId}`;
-        btn.style.cssText = 'display:block; margin:4px 0; background:rgba(34,197,94,0.12); border:1px solid rgba(34,197,94,0.3); border-radius:8px; padding:8px 12px; cursor:pointer; font-size:0.8rem; color:#4ade80;';
-        btn.onclick = () => window.aiChat.deploy(extra.appId);
+        btn.className = 'ai-act deploy';
+        btn.textContent = `🚀 Deploy ${esc(extra.appName || extra.appId)}`;
+        btn.addEventListener('click', () => deploy(extra.appId));
         extraDiv.appendChild(btn);
       }
-      if (extra.suggestions) {
-        const list = document.createElement('div');
-        list.style.cssText = 'font-size:0.78rem; color:var(--text-muted,#888); padding:4px 0;';
-        list.innerHTML = extra.suggestions.map(s => '• ' + s).join('<br>');
-        extraDiv.appendChild(list);
-      }
       if (extra.action === 'diagnose') {
         const btn = document.createElement('button');
+        btn.className = 'ai-act warn';
         btn.textContent = '🔍 Run Diagnostics';
-        btn.style.cssText = 'display:block; margin:4px 0; background:rgba(251,191,36,0.12); border:1px solid rgba(251,191,36,0.3); border-radius:8px; padding:8px 12px; cursor:pointer; font-size:0.8rem; color:#fbbf24;';
-        btn.onclick = () => window.location.href = '#health';
+        btn.addEventListener('click', () => { window.location.href = '#health'; });
         extraDiv.appendChild(btn);
       }
       if (extra.action === 'backup') {
         const btn = document.createElement('button');
+        btn.className = 'ai-act blue';
         btn.textContent = '💾 Create Backup';
-        btn.style.cssText = 'display:block; margin:4px 0; background:rgba(99,102,241,0.12); border:1px solid rgba(99,102,241,0.3); border-radius:8px; padding:8px 12px; cursor:pointer; font-size:0.8rem; color:#a5b4fc;';
-        btn.onclick = () => { if (window.createBackup) window.createBackup(); };
+        btn.addEventListener('click', () => { if (window.createBackup) window.createBackup(); });
         extraDiv.appendChild(btn);
       }
+      if (Array.isArray(extra.suggestions)) {
+        const list = document.createElement('div');
+        list.className = 'ai-note';
+        list.textContent = 'Try: ' + extra.suggestions.join(' · ');
+        extraDiv.appendChild(list);
+      }
       container.appendChild(extraDiv);
     }
     container.scrollTop = container.scrollHeight;
@@ -120,16 +213,14 @@
 
   async function send(prefilled) {
     const input = document.getElementById('ai-chat-input');
-    const message = prefilled || input.value.trim();
-    if (!message) return;
-    input.value = '';
+    const raw = prefilled || (input && input.value.trim()) || '';
+    if (!raw) return;
+    if (input) input.value = '';
 
-    addMessage('user', message);
+    addMessage('user', raw);
 
-    // Typing indicator
     const container = document.getElementById('ai-chat-messages');
     const typing = document.createElement('div');
-    typing.id = 'ai-typing';
     typing.style.cssText = 'align-self:flex-start; color:var(--text-muted,#666); font-size:0.8rem; padding:8px 14px;';
     typing.textContent = '🤖 Thinking...';
     container.appendChild(typing);
@@ -139,17 +230,31 @@
       const res = await secureFetch('/api/v1/ai/intent', {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ message, context: {} })
+        // history: prior turns EXCLUDING the just-added user line
+        body: JSON.stringify({ message: raw.slice(0, 1000), history: chatTurns.slice(0, -1) }),
       });
       const data = await res.json();
       typing.remove();
 
-      if (data.success !== false && data.data) {
-        const r = data.data;
-        const response = r.response || {};
-        addMessage('ai', response.message || r.response?.message || 'Action: ' + (r.action || r.intent), response);
+      if (data && data.success !== false && data.intent) {
+        const resp = data.response || {};
+        const text = resp.message || data.llmReply || ('Action: ' + (data.action || data.intent));
+        addMessage('ai', text, {
+          ...resp,
+          engine: data.engine,
+          llmError: data.llmError,
+          appId: data.appId || resp.appId,
+          appName: data.appName || resp.appName,
+          action: data.intent,
+          suggestions: resp.suggestions,
+        });
+        const badge = document.getElementById('ai-status');
+        if (badge && data.engine === 'llm') {
+          // remember live engine flip (config could have just been set)
+          engineInfo.engine = 'llm';
+        }
       } else {
-        addMessage('ai', data.error || 'Sorry, something went wrong.');
+        addMessage('ai', (data && data.error) || 'Sorry, something went wrong.');
       }
     } catch (e) {
       typing.remove();
@@ -158,16 +263,88 @@
   }
 
   async function deploy(appId) {
-    addMessage('user', 'Deploy ' + appId);
-    addMessage('ai', `Launching ${appId} from the catalog...`);
-    // Trigger the app selector with this app
-    if (window.openAppSelector) {
-      window.openAppSelector(appId);
-    } else {
-      addMessage('ai', `Search for ${appId} in the App Catalog to deploy it.`);
+    if (typeof window.openDeployConfigFor === 'function') {
+      const r = await window.openDeployConfigFor(appId);
+      if (r === true) { addMessage('ai', `Opened the deploy setup for ${appId} — pick a subdomain and confirm.`); return; }
+      if (r === 'selector') { addMessage('ai', `${appId} is a dashboard widget — open it from the app grid to toggle it.`); return; }
     }
+    addMessage('ai', `Template "${appId}" not found in the catalog. Open the + menu to browse apps.`);
   }
 
+  // ── ⚙ settings modal ──────────────────────────────────────────────────────
+  function openSettings() {
+    const old = document.getElementById('ai-llm-settings-modal');
+    if (old) old.remove();
+    const m = document.createElement('div');
+    m.id = 'ai-llm-settings-modal';
+    m.style.cssText = 'position:fixed; inset:0; background:rgba(0,0,0,0.6); z-index:10000; display:flex; align-items:center; justify-content:center;';
+    m.innerHTML = `
+      <div style="background:var(--bg-card,#16162a); border:1px solid var(--border,#333); border-radius:12px; padding:20px; width:420px; max-width:92vw; display:flex; flex-direction:column; gap:10px;">
+        <div style="font-weight:700;">AI assistant — LLM engine</div>
+        <div class="ai-note" style="color:var(--text-muted,#888); font-size:0.75rem;">Any OpenAI-compatible endpoint. Stored in the encrypted credential store (never in browser-exposed config). Leave the key blank to keep the stored one. Without an LLM the assistant still works on the offline pattern engine.</div>
+        <label style="font-size:0.78rem;">Base URL <input id="ai-cfg-base" class="ai-in" placeholder="https://api.example.com/v1" style="width:100%;box-sizing:border-box;"></label>
+        <label style="font-size:0.78rem;">Model <input id="ai-cfg-model" class="ai-in" placeholder="gpt-4o-mini"></label>
+        <label style="font-size:0.78rem;">API key <input id="ai-cfg-key" class="ai-in" type="password" autocomplete="off" placeholder="stored key unchanged"></label>
+        <div id="ai-cfg-state" class="ai-note"></div>
+        <div style="display:flex; gap:8px; justify-content:flex-end;">
+          <button id="ai-cfg-test" class="ai-act blue">Test</button>
+          <button id="ai-cfg-save" class="ai-act deploy">Save</button>
+          <button id="ai-cfg-clear" class="ai-act warn">Remove LLM</button>
+          <button id="ai-cfg-close" class="ai-act">Close</button>
+        </div>
+      </div>`;
+    document.body.appendChild(m);
+    const $ = (id) => document.getElementById(id);
+    const state = (t) => { $('ai-cfg-state').textContent = t; };
+
+    fetch('/api/v1/ai/settings').then((r) => r.json()).then((d) => {
+      if (d && d.success) {
+        $('ai-cfg-base').value = d.baseUrl || '';
+        $('ai-cfg-model').value = d.model || '';
+        state(d.configured ? `Active via ${d.source}. ${d.hasApiKey ? 'Key stored.' : 'No key.'}` : 'Not configured — pattern engine in use.');
+        if (d.source === 'env') $('ai-cfg-key').placeholder = 'env key in use — set to override';
+      }
+    }).catch(() => state('Could not load current settings.'));
+
+    $('ai-cfg-close').onclick = () => m.remove();
+    m.addEventListener('click', (e) => { if (e.target === m) m.remove(); });
+    $('ai-cfg-save').onclick = async () => {
+      state('Saving…');
+      try {
+        const r = await secureFetch('/api/v1/ai/settings', {
+          method: 'PUT',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({ baseUrl: $('ai-cfg-base').value, model: $('ai-cfg-model').value, apiKey: $('ai-cfg-key').value }),
+        });
+        const d = await r.json();
+        state(d.success ? 'Saved. The assistant now classifies with ' + (d.model || 'your model') + '.' : (d.error || 'Save failed.'));
+        if (d.success) { $('ai-cfg-key').value = ''; refreshEngineBadge(); }
+      } catch (e) { state('Save error: ' + e.message); }
+    };
+    $('ai-cfg-test').onclick = async () => {
+      state('Testing… (one classification round-trip)');
+      try {
+        const r = await secureFetch('/api/v1/ai/settings/test', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: '{}' });
+        const d = await r.json();
+        if (d.success && d.ok) state(`✅ Works — sample: "${d.sample.intent}"${d.sample.reply ? ' — ' + d.sample.reply : ''}`);
+        else state('❌ ' + (d.reason || d.error || 'test failed'));
+      } catch (e) { state('Test error: ' + e.message); }
+    };
+    $('ai-cfg-clear').onclick = async () => {
+      state('Removing…');
+      try {
+        const r = await secureFetch('/api/v1/ai/settings', { method: 'DELETE' });
+        const d = await r.json();
+        state(d.success ? 'Removed — pattern engine active.' : (d.error || 'failed'));
+        refreshEngineBadge();
+      } catch (e) { state('Error: ' + e.message); }
+    };
+  }
+
+  document.addEventListener('click', (e) => {
+    if (e.target && e.target.id === 'ai-settings-btn') openSettings();
+  }, true);
+
   window.aiChat = { send, deploy, toggle };
   window.toggleAIChat = toggle;
 })();
diff --git a/status/js/app-selector.js b/status/js/app-selector.js
index c9f8d67..a588217 100644
--- a/status/js/app-selector.js
+++ b/status/js/app-selector.js
@@ -917,6 +917,28 @@
     modal.classList.add('show');
   });
 
+  // DC-163: programmatic deploy-config opener for the AI chat panel (and
+  // any other in-page consumer). Resolves the template id against the
+  // cached API templates (fetching them if needed), then opens the same
+  // deploy modal a manual click would. Returns false for unknown ids.
+  window.openDeployConfigFor = async function (templateId) {
+    if (!apiTemplates) {
+      const okFetch = await fetchAppTemplates();
+      if (!okFetch) return false;
+    }
+    const key = String(templateId || '').toLowerCase();
+    const entry = Object.entries(apiTemplates).find(([id]) => id.toLowerCase() === key);
+    if (!entry) return false;
+    const app = { id: entry[0], ...entry[1] };
+    if (app.isDashboardWidget) {
+      await buildAppSelector();
+      modal.classList.add('show');
+      return 'selector'; // widget — point at the selector grid instead
+    }
+    await showDeployConfig(app);
+    return true;
+  };
+
   wireModal(modal, document.getElementById('app-selector-cancel'));
 
   // Deploy modal event listeners
diff --git a/status/sw.js b/status/sw.js
index a5a33eb..2209cea 100644
--- a/status/sw.js
+++ b/status/sw.js
@@ -1,4 +1,4 @@
-const CACHE = 'dashcaddy-shell-37f9769c30';
+const CACHE = 'dashcaddy-shell-c62511c40d';
 const PRECACHE = [
   '/',
   '/index.html',