aegis-desktop 0.3.0 → 0.4.0

package/renderer/index.html

@@ -26,6 +26,15 @@
     <button type="button" id="new-chat" class="ghost-btn">New chat</button>
   </header>
 
+  <div class="update-banner" id="update-banner" role="status" hidden>
+    <span id="update-banner-text"></span>
+    <div class="update-banner-actions">
+      <button type="button" id="update-download-btn" class="ghost-btn" hidden>Download</button>
+      <button type="button" id="update-restart-btn" class="ghost-btn" hidden>Restart to install</button>
+      <button type="button" id="update-later-btn" class="ghost-btn">Later</button>
+    </div>
+  </div>
+
   <main>
     <aside class="side">
       <section class="card">
@@ -115,10 +124,46 @@
         <p class="hint" id="settings-hint"></p>
       </section>
 
+      <section class="card">
+        <h2>Quick Launcher</h2>
+        <label
+          class="flow-toggle"
+          for="quick-launcher-enabled"
+          title="Register a systemwide keyboard shortcut that opens a small always-on-top prompt window from anywhere on the desktop, even when AEGIS Desktop isn't focused. Packaged builds always have it on; this toggle is for a dev run."
+        >
+          <input type="checkbox" id="quick-launcher-enabled" />
+          <span>enable global shortcut</span>
+        </label>
+        <div class="api-key-row">
+          <input
+            type="text"
+            id="quick-launcher-shortcut"
+            placeholder="CmdOrCtrl+Shift+Space"
+            autocomplete="off"
+          />
+          <button type="button" id="quick-launcher-save" class="ghost-btn">Save</button>
+        </div>
+        <p class="hint" id="quick-launcher-hint"></p>
+      </section>
+
+      <section class="card">
+        <h2>Tool approvals</h2>
+        <label
+          class="flow-toggle"
+          for="confirm-mode-toggle"
+          title="When on, every exec / writeFile / editFile tool call is previewed and needs your approval (once, for the session, or denied) before it runs. Turn it off to let the agent run those tools without asking."
+        >
+          <input type="checkbox" id="confirm-mode-toggle" />
+          <span>confirm before running tools</span>
+        </label>
+        <p class="hint" id="confirm-mode-hint"></p>
+      </section>
+
       <section class="card">
         <h2>Sessions</h2>
         <button type="button" id="sessions-refresh" class="ghost-btn">Refresh</button>
         <button type="button" id="sync-now" class="ghost-btn">Sync now</button>
+        <button type="button" id="sessions-export" class="ghost-btn">Export</button>
         <ul class="sessions-list" id="sessions-list"></ul>
         <p class="hint" id="sessions-hint"></p>
         <p class="hint" id="sync-status"></p>
@@ -284,6 +329,10 @@
   </div>
 
   <script src="max-tokens.js"></script>
+  <script src="vendor/marked.umd.js"></script>
+  <script src="vendor/purify.min.js"></script>
+  <script src="vendor/aegis-highlight.js"></script>
+  <script src="markdown.js"></script>
   <script src="app.js"></script>
 </body>
 </html>

package/renderer/markdown.js

@@ -0,0 +1,165 @@
+'use strict';
+
+/**
+ * Assistant-message markdown rendering: marked -> DOMPurify -> DOM
+ * postprocessing (syntax highlight + copy buttons on fenced code, external
+ * link rewiring). This is the ONLY path that may put model output into
+ * innerHTML — everywhere else in app.js, assistant/user text stays
+ * textContent. See renderInto() below.
+ *
+ * Loaded as a classic script (CSP script-src 'self', no bundler) after
+ * vendor/marked.umd.js, vendor/purify.min.js and vendor/aegis-highlight.js
+ * (all under renderer/vendor/ — desktop/vendor/ is a predist.mjs staging
+ * dir that the repo's pre-commit hook blocks from ever being committed),
+ * before app.js. Exposes window.AegisMarkdown.
+ *
+ * UMD-lite like aegis-highlight.js: CommonJS export for the pure, DOM-free
+ * helpers so they're unit-testable in plain Node; the DOM-dependent half
+ * (renderInto) only runs under a real document (Electron renderer).
+ */
+(function (root, factory) {
+  const mod = factory();
+  if (typeof module === 'object' && module.exports) {
+    module.exports = mod;
+  } else {
+    root.AegisMarkdown = mod;
+  }
+})(typeof globalThis !== 'undefined' ? globalThis : this, function () {
+  /**
+   * Is `href` an absolute http(s) URL — something that could plausibly be
+   * opened externally? Deliberately parsed with NO base: a relative path or
+   * bare "#anchor" has no scheme and must fail to parse here, not silently
+   * inherit https: from a placeholder base (that was the original bug —
+   * every relative href came back "external"). This is defense in depth
+   * only — main.js's isSafeExternalUrl is the real gate before anything
+   * reaches the OS shell.
+   */
+  function isExternalHref(href) {
+    if (typeof href !== 'string' || !href) return false;
+    try {
+      const url = new URL(href);
+      return url.protocol === 'http:' || url.protocol === 'https:';
+    } catch {
+      return false;
+    }
+  }
+
+  /** "language-js" -> "js"; "" for a code block with no fence language. */
+  function langFromClassName(className) {
+    const m = /language-([\w-]+)/.exec(className || '');
+    return m ? m[1] : '';
+  }
+
+  let markedConfigured = false;
+  function configureMarked(marked) {
+    if (markedConfigured) return;
+    marked.setOptions({ gfm: true, breaks: false });
+    markedConfigured = true;
+  }
+
+  /** Markdown -> raw (unsanitized) HTML, or null if marked isn't loaded —
+   *  callers must treat null as "render as plain text", never as HTML. */
+  function toHtml(markdownText) {
+    const marked = typeof window !== 'undefined' ? window.marked : null;
+    if (!marked || typeof marked.parse !== 'function') return null;
+    configureMarked(marked);
+    return marked.parse(markdownText == null ? '' : String(markdownText));
+  }
+
+  /** Raw HTML -> sanitized HTML, or null if DOMPurify isn't loaded/ready. */
+  function sanitize(html) {
+    const DOMPurify = typeof window !== 'undefined' ? window.DOMPurify : null;
+    if (!DOMPurify || typeof DOMPurify.sanitize !== 'function') return null;
+    return DOMPurify.sanitize(html, {
+      // Restrict link/media URIs to what isExternalHref()/rewireLinks()
+      // actually know how to handle; javascript:/data:/file:/mailto: etc.
+      // never survive (mailto has no OS-shell path through openExternal,
+      // which only allows http/https — see main.js isSafeExternalUrl).
+      ALLOWED_URI_REGEXP: /^(?:https?:|#)/i,
+    });
+  }
+
+  /**
+   * Highlight + add a copy button to one fenced-code `<pre>`. Runs on the
+   * live sanitized DOM, reading the code's real text (already unescaped by
+   * the browser's own HTML parsing) and replacing it with our own
+   * self-escaping highlighter output — never re-feeding anything through
+   * innerHTML that didn't originate from AegisHighlight.escapeHtml.
+   */
+  function decorateCodeBlock(preEl) {
+    const codeEl = preEl.querySelector('code');
+    if (!codeEl) return;
+    const lang = langFromClassName(codeEl.className);
+    const raw = codeEl.textContent || '';
+    const AegisHighlight = typeof window !== 'undefined' ? window.AegisHighlight : null;
+    if (AegisHighlight) {
+      codeEl.innerHTML = AegisHighlight.highlight(raw, lang);
+    }
+    preEl.classList.add('code-block');
+
+    const btn = document.createElement('button');
+    btn.type = 'button';
+    btn.className = 'code-copy-btn';
+    btn.textContent = 'copy';
+    btn.addEventListener('click', () => {
+      navigator.clipboard.writeText(raw).then(
+        () => {
+          btn.textContent = 'copied!';
+          setTimeout(() => { btn.textContent = 'copy'; }, 1500);
+        },
+        () => {
+          btn.textContent = 'copy failed';
+          setTimeout(() => { btn.textContent = 'copy'; }, 1500);
+        }
+      );
+    });
+    preEl.appendChild(btn);
+  }
+
+  /**
+   * Every link in rendered markdown opens in the OS default browser via the
+   * aegis.openExternal IPC bridge, never as in-app navigation (a stray
+   * `<a href>` reaching BrowserWindow's default handler would point the
+   * chat UI itself at an arbitrary model-supplied origin).
+   */
+  function rewireLinks(container) {
+    const aegis = typeof window !== 'undefined' ? window.aegis : null;
+    const links = container.querySelectorAll('a[href]');
+    for (const a of links) {
+      const href = a.getAttribute('href');
+      a.removeAttribute('target');
+      a.setAttribute('rel', 'noopener noreferrer');
+      if (!isExternalHref(href)) {
+        // Not absolute http(s) (e.g. an in-page "#" anchor) — strip the
+        // href outright rather than let it fall through to default
+        // navigation inside the app's own BrowserWindow.
+        a.removeAttribute('href');
+        continue;
+      }
+      a.addEventListener('click', (e) => {
+        e.preventDefault();
+        if (aegis && typeof aegis.openExternal === 'function') aegis.openExternal(href);
+      });
+    }
+  }
+
+  /**
+   * Render `markdownText` into `containerEl`, replacing its contents.
+   * Always sanitized; falls back to a plain-text node (never raw innerHTML)
+   * when marked or DOMPurify failed to load. This is the only function in
+   * the renderer allowed to put model output into innerHTML.
+   */
+  function renderInto(containerEl, markdownText) {
+    const html = toHtml(markdownText);
+    const safe = html == null ? null : sanitize(html);
+    if (safe == null) {
+      containerEl.textContent = markdownText == null ? '' : String(markdownText);
+      return;
+    }
+    containerEl.innerHTML = safe;
+    for (const pre of containerEl.querySelectorAll('pre')) decorateCodeBlock(pre);
+    rewireLinks(containerEl);
+  }
+
+  return { renderInto, isExternalHref, langFromClassName };
+});

package/renderer/quick.css

@@ -0,0 +1,126 @@
+:root {
+  --bg: #0d1117;
+  --surface: #12161e;
+  --border: #2a3342;
+  --text: #d0dfee;
+  --text2: #7e9ab8;
+  --teal: #00e5c0;
+  --red: #ff1744;
+}
+
+* {
+  box-sizing: border-box;
+}
+
+html,
+body {
+  height: 100%;
+}
+
+body {
+  margin: 0;
+  background: transparent;
+  color: var(--text);
+  font: 14px/1.4 -apple-system, 'Segoe UI', system-ui, sans-serif;
+}
+
+.ql-shell {
+  display: flex;
+  flex-direction: column;
+  height: 100%;
+  padding: 12px;
+  gap: 8px;
+  background: var(--bg);
+  border: 1px solid var(--border);
+  border-radius: 10px;
+  overflow: hidden;
+}
+
+.ql-head {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  font-size: 12px;
+  color: var(--text2);
+}
+
+.ql-badge {
+  font-weight: 700;
+  letter-spacing: 0.04em;
+  color: var(--teal);
+}
+
+.ql-model {
+  color: var(--text2);
+}
+
+.ql-model-select {
+  background: var(--surface);
+  color: var(--text);
+  border: 1px solid var(--border);
+  border-radius: 4px;
+  font-size: 12px;
+  padding: 2px 4px;
+}
+
+.ql-spacer {
+  flex: 1 1 auto;
+}
+
+.ql-stop,
+.ql-push {
+  background: var(--surface);
+  color: var(--text);
+  border: 1px solid var(--border);
+  border-radius: 6px;
+  font-size: 12px;
+  padding: 4px 8px;
+  cursor: pointer;
+}
+
+.ql-stop:hover,
+.ql-push:hover {
+  border-color: var(--teal);
+  color: var(--teal);
+}
+
+.ql-stop {
+  border-color: var(--red);
+  color: var(--red);
+}
+
+.ql-prompt {
+  resize: none;
+  background: var(--surface);
+  color: var(--text);
+  border: 1px solid var(--border);
+  border-radius: 6px;
+  padding: 8px;
+  font: inherit;
+}
+
+.ql-prompt:focus {
+  outline: none;
+  border-color: var(--teal);
+}
+
+.ql-response {
+  flex: 1 1 auto;
+  overflow-y: auto;
+  white-space: pre-wrap;
+  font-size: 13px;
+  color: var(--text);
+  padding: 0 2px;
+}
+
+.ql-response:empty::before {
+  content: '';
+}
+
+.ql-foot {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  font-size: 11px;
+  color: var(--text2);
+}

package/renderer/quick.html

@@ -0,0 +1,39 @@
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <meta
+    http-equiv="Content-Security-Policy"
+    content="default-src 'none'; script-src 'self'; style-src 'self'; img-src 'self' data:"
+  />
+  <title>AEGIS Quick Launcher</title>
+  <link rel="stylesheet" href="quick.css" />
+</head>
+<body>
+  <form id="ql-form" class="ql-shell">
+    <div class="ql-head">
+      <span class="ql-badge">AEGIS</span>
+      <span class="ql-model" id="ql-model-label">Aegis Cloud</span>
+      <select id="ql-model-select" class="ql-model-select" title="Model" hidden></select>
+      <div class="ql-spacer"></div>
+      <button type="button" id="ql-stop" class="ql-stop" hidden>Stop</button>
+    </div>
+    <textarea
+      id="ql-prompt"
+      class="ql-prompt"
+      rows="2"
+      placeholder="Ask AEGIS… (Enter to ask, Esc to close)"
+      autocomplete="off"
+    ></textarea>
+    <div class="ql-response" id="ql-response" aria-live="polite"></div>
+    <div class="ql-foot">
+      <span class="ql-hint" id="ql-status">Enter to ask · Esc to close</span>
+      <div class="ql-spacer"></div>
+      <button type="button" id="ql-push" class="ql-push" hidden>
+        Add to chat (⌘/Ctrl+⏎)
+      </button>
+    </div>
+  </form>
+  <script src="quick.js"></script>
+</body>
+</html>

package/renderer/quick.js

@@ -0,0 +1,188 @@
+'use strict';
+
+/**
+ * AEGIS Quick Launcher renderer — a one-shot prompt over window.models.chat
+ * (the same LocalEngine transport the main window's chat uses), with the
+ * agent loop's tool calling turned off (`tools: false`): a small always-
+ * on-top popup is the wrong place for a tool-approval card to pop up in.
+ *
+ * Same contextIsolation/sandbox posture as renderer/app.js — talks only to
+ * window.models / window.quickLauncher, both whitelisted by preload.js.
+ */
+
+(function () {
+  if (!window.models || !window.quickLauncher) {
+    document.body.textContent =
+      'This page must run inside the AEGIS Electron host (window.models/window.quickLauncher missing).';
+    throw new Error('window.models/window.quickLauncher unavailable — not running under Electron');
+  }
+
+  const models = window.models;
+  const quickLauncher = window.quickLauncher;
+
+  const CLASS = 'aegis';
+  const MODEL_KEY = 'quick-launcher-model';
+  const IDLE_HINT = 'Enter to ask · Esc to close';
+
+  const els = {
+    form: document.getElementById('ql-form'),
+    prompt: document.getElementById('ql-prompt'),
+    response: document.getElementById('ql-response'),
+    modelLabel: document.getElementById('ql-model-label'),
+    modelSelect: document.getElementById('ql-model-select'),
+    stopBtn: document.getElementById('ql-stop'),
+    pushBtn: document.getElementById('ql-push'),
+    status: document.getElementById('ql-status'),
+  };
+
+  let busy = false;
+  let sessionId = null;
+  let lastPrompt = '';
+  let lastResponse = '';
+  let hasResult = false;
+
+  function setStatus(text) {
+    els.status.textContent = text;
+  }
+
+  function setBusy(next) {
+    busy = next;
+    els.stopBtn.hidden = !next;
+    els.prompt.disabled = next;
+  }
+
+  /** Populate the model picker for the fixed 'aegis' class. Degrades to a
+   *  plain label (no picker) when there is no key configured or the catalog
+   *  call fails — the launcher still opens, it just can't send anything. */
+  async function loadModel() {
+    try {
+      const classes = (await models.listClasses()) || [];
+      const aegisClass = classes.find((c) => c.class === CLASS);
+      if (!aegisClass || !aegisClass.configured) {
+        els.modelLabel.textContent = 'Aegis Cloud — no key configured';
+        els.modelSelect.hidden = true;
+        return;
+      }
+      const data = await models.listModels(CLASS);
+      const list = (data && data.models) || [];
+      els.modelSelect.innerHTML = '';
+      for (const m of list) {
+        const opt = document.createElement('option');
+        opt.value = m.id;
+        opt.textContent = m.label || m.id;
+        els.modelSelect.appendChild(opt);
+      }
+      const saved = localStorage.getItem(MODEL_KEY);
+      if (saved && list.some((m) => m.id === saved)) {
+        els.modelSelect.value = saved;
+      }
+      els.modelSelect.hidden = list.length <= 1;
+      els.modelLabel.textContent = 'Aegis Cloud';
+    } catch {
+      els.modelLabel.textContent = 'Aegis Cloud — unavailable';
+      els.modelSelect.hidden = true;
+    }
+  }
+
+  els.modelSelect.addEventListener('change', () => {
+    localStorage.setItem(MODEL_KEY, els.modelSelect.value);
+  });
+
+  async function ask(prompt) {
+    if (!prompt || busy) return;
+    hasResult = false;
+    els.pushBtn.hidden = true;
+    els.response.textContent = '';
+    setBusy(true);
+    setStatus('thinking…');
+    sessionId = `quick-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+    let text = '';
+    try {
+      const res = await models.chat(
+        {
+          class: CLASS,
+          model: els.modelSelect.value || undefined,
+          prompt,
+          tools: false,
+          sessionId,
+        },
+        (chunk) => {
+          if (chunk && typeof chunk.delta === 'string' && chunk.delta) {
+            text += chunk.delta;
+            els.response.textContent = text;
+            els.response.scrollTop = els.response.scrollHeight;
+          }
+        }
+      );
+      const msg = res && res.choices && res.choices[0] && res.choices[0].message;
+      const finalText = text || (msg && msg.content) || '';
+      els.response.textContent = finalText;
+      lastPrompt = prompt;
+      lastResponse = finalText;
+      hasResult = Boolean(finalText);
+      els.pushBtn.hidden = !hasResult;
+      setStatus(hasResult ? '⌘/Ctrl+⏎ to add this to the main chat' : 'no answer');
+    } catch (err) {
+      els.response.textContent = `Error: ${err && err.message ? err.message : err}`;
+      setStatus('failed');
+    } finally {
+      setBusy(false);
+      sessionId = null;
+    }
+  }
+
+  function stop() {
+    if (sessionId) models.cancel(sessionId).catch(() => {});
+  }
+
+  function pushToMain() {
+    if (!hasResult) return;
+    quickLauncher
+      .pushToMain({
+        prompt: lastPrompt,
+        response: lastResponse,
+        model: els.modelSelect.value || null,
+      })
+      .catch(() => {});
+  }
+
+  els.form.addEventListener('submit', (e) => {
+    e.preventDefault();
+    ask(els.prompt.value.trim());
+  });
+
+  els.prompt.addEventListener('keydown', (e) => {
+    if (e.key === 'Enter' && (e.metaKey || e.ctrlKey)) {
+      e.preventDefault();
+      pushToMain();
+      return;
+    }
+    if (e.key === 'Enter' && !e.shiftKey) {
+      e.preventDefault();
+      ask(els.prompt.value.trim());
+    }
+  });
+
+  els.stopBtn.addEventListener('click', stop);
+  els.pushBtn.addEventListener('click', pushToMain);
+
+  // The window is shown/hidden, not reloaded, on every shortcut press (see
+  // main.js toggleQuickLauncher) — so each time it regains focus is a fresh
+  // "session" from the user's point of view and should start clean, unless a
+  // stream from the previous session is still running in the background.
+  window.addEventListener('focus', () => {
+    if (busy) {
+      els.prompt.focus();
+      return;
+    }
+    els.prompt.value = '';
+    els.response.textContent = '';
+    els.pushBtn.hidden = true;
+    hasResult = false;
+    setStatus(IDLE_HINT);
+    els.prompt.focus();
+  });
+
+  loadModel();
+  els.prompt.focus();
+})();