aegis-desktop 1.0.10 → 1.0.13

package/renderer/provider-toolbar.js

@@ -0,0 +1,136 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// Copyright (C) 2026 Niklas Borneklint — AEGIS Code (aegiscode) / Aegiscloud.
+// AEGIS Code (aegiscode) — source: https://github.com/aegisinfo/aegiscode-plugin
+// Conveying a modified copy, or running one as a network service, owes the
+// corresponding source under this licence (§5/§13) — see LICENSING.md.
+'use strict';
+
+/**
+ * provider-toolbar.js — the Providers & models card: one list, every provider
+ * and every model, each with the URL its turn is sent to.
+ *
+ * Paints data from providers.js and nothing else; it never fetches, so the
+ * list cannot disagree with the engine's own catalog. Two rules the markup
+ * obeys:
+ *
+ *   - A row is a <button> (not a div with a click handler) when it is
+ *     selectable, so it is reachable by keyboard and announces itself. A
+ *     non-selectable row (a class's state: "no key", "no daemon") is a plain
+ *     <li> — making it a button would promise a click that does nothing.
+ *   - The URL line is text, never a link: these are addresses the app sends to,
+ *     not things a user should open. A chrome-less window opening its own IPC
+ *     base in a browser is noise at best.
+ */
+
+(function () {
+  if (typeof window === 'undefined') return;
+  const A = window.aegisProviders;
+  if (!A) return; // providers.js missing: leave the card on its placeholder
+
+  function el(tag, cls, text) {
+    const n = document.createElement(tag);
+    if (cls) n.className = cls;
+    if (text != null) n.textContent = text;
+    return n;
+  }
+
+  /**
+   * @param {object} opts
+   * @param {HTMLElement} opts.list     container for the rows
+   * @param {HTMLElement} opts.count    "N of M" line
+   * @param {HTMLInputElement} opts.search
+   * @param {HTMLElement} opts.hint
+   * @param {(sel:{class:string,model:string})=>void} opts.onSelect
+   */
+  function mount(opts) {
+    const o = opts || {};
+    let entries = [];
+
+    function paintRow(e) {
+      const li = el('li', 'pt-row');
+      if (e.selectable) {
+        const btn = el('button', 'pt-pick');
+        btn.type = 'button';
+        btn.appendChild(el('span', 'pt-model', e.modelLabel || e.model));
+        if (e.model && e.modelLabel && e.modelLabel !== e.model) {
+          btn.appendChild(el('span', 'pt-id', e.model));
+        }
+        btn.appendChild(el('span', 'pt-target', e.url ? `${e.method} ${e.url}` : 'no network route — runs as a local process'));
+        btn.addEventListener('click', () => {
+          if (o.onSelect) o.onSelect(A.selectionFor(e));
+        });
+        li.appendChild(btn);
+      } else {
+        li.appendChild(el('span', 'pt-model pt-muted', e.modelLabel));
+        li.appendChild(el('span', 'pt-target', e.url ? `${e.method} ${e.url}` : '—'));
+      }
+      if (e.billing) li.appendChild(el('span', 'pt-billing', e.billing));
+      if (e.blocked) li.appendChild(el('span', 'pt-blocked', e.blocked));
+      return li;
+    }
+
+    /** Group rows under their class heading, preserving class order. */
+    function paint(query) {
+      const shown = A.filterEntries(entries, query);
+      if (o.count) {
+        o.count.textContent = entries.length
+          ? `${shown.length} of ${entries.length} provider route${entries.length === 1 ? '' : 's'}`
+          : 'no providers reported';
+      }
+      if (o.list) {
+        o.list.innerHTML = '';
+        let group = null;
+        let ul = null;
+        for (const e of shown) {
+          if (e.group !== group) {
+            group = e.group;
+            const section = el('li', 'pt-group');
+            section.appendChild(el('h3', 'pt-group-title', group));
+            ul = el('ul', 'pt-rows');
+            section.appendChild(ul);
+            o.list.appendChild(section);
+          }
+          ul.appendChild(paintRow(e));
+        }
+        if (!shown.length) {
+          o.list.appendChild(el('li', 'pt-empty', entries.length
+            ? 'No provider or model matches that filter.'
+            : 'No provider paths yet — press Refresh once a key is saved.'));
+        }
+      }
+      if (o.hint && query && shown.length) {
+        // Say where each hit goes, in one line, so the tallest question the
+        // list answers ("does this leave my machine?") is answerable at a
+        // glance rather than row by row.
+        const remote = shown.filter((e) => e.url && !/localhost|127\.0\.0\.1/.test(e.url)).length;
+        const local = shown.filter((e) => e.url && /localhost|127\.0\.0\.1/.test(e.url)).length;
+        const off = shown.filter((e) => !e.url).length;
+        o.hint.textContent = [
+          remote ? `${remote} over the network` : '',
+          local ? `${local} on this machine` : '',
+          off ? `${off} with no route` : '',
+        ].filter(Boolean).join(' · ');
+      } else if (o.hint && !query) {
+        o.hint.textContent = entries.length
+          ? 'Every provider this build can address, and the URL a turn to it uses.'
+          : '';
+      }
+    }
+
+    if (o.search) {
+      o.search.addEventListener('input', () => paint(o.search.value));
+    }
+
+    return {
+      /** Replace the list. `rows` is the same shape buildProviderPaths takes. */
+      set(rows) {
+        entries = A.buildProviderPaths(rows);
+        paint(o.search ? o.search.value : '');
+        return entries;
+      },
+      entries: () => entries.slice(),
+    };
+  }
+
+  window.aegisProviderToolbar = { mount };
+})();

package/renderer/providers.js

@@ -0,0 +1,261 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// Copyright (C) 2026 Niklas Borneklint — AEGIS Code (aegiscode) / Aegiscloud.
+// AEGIS Code (aegiscode) — source: https://github.com/aegisinfo/aegiscode-plugin
+// Conveying a modified copy, or running one as a network service, owes the
+// corresponding source under this licence (§5/§13) — see LICENSING.md.
+'use strict';
+
+/**
+ * providers.js — one flat list of every provider and every model this build can
+ * address, each with the URL a turn to it actually goes to.
+ *
+ * WHY THIS EXISTS. The Model card answers "what is selected"; it never answers
+ * "what can I select, and where does that go". Those are different questions,
+ * and the second one had no surface at all: a user could see four provider
+ * classes and one model dropdown, and still have no way to learn that
+ * `byok:anthropic:claude-sonnet-5` is sent to the relay, that `local:llama3.2`
+ * goes to localhost, or that `pro` is not a URL at all but a child process.
+ *
+ * TWO DELIBERATE OMISSIONS, and they are the point of the file's shape:
+ *
+ *   - No φ(α) seal row. The authorship panel is not a provider; it publishes a
+ *     record of a repo, and putting it in a provider table would invite the
+ *     reader to think a turn can be addressed to it.
+ *   - No autonomous-box row. The fan-out is a *property of a turn* on the
+ *     Aegis Cloud class (engine.js AUTONOMOUS_CLASS), not an endpoint — it
+ *     reaches no route the pooled row does not already name. It already has its
+ *     own toggle in the Model card, next to the class that has it at all.
+ *
+ * Both omissions are asserted in test/renderer-providers.test.mjs so a later
+ * "why is this missing" pass cannot quietly re-add them.
+ *
+ * The URLS ARE READ OFF THE TRANSPORT, not guessed:
+ *   - pooled  : vendor/aegis.js -> '/api/v1/chat/completions', under
+ *               DEFAULT_API_BASE ('https://aegiscloud.org')
+ *   - byok    : vendor/aegis.js -> '/api/v1/byok/chat/completions', same base,
+ *               with a per-request X-Provider-Key
+ *   - local   : lib/local/local.js -> `${base}/v1/chat/completions`, base
+ *               DEFAULT_BASE ('http://localhost:11434')
+ *   - pro     : no route — a `claude` child process (claude-pro.js PRO_MODELS
+ *               are CLI aliases, not wire ids), so `url` is null and the row
+ *               says so instead of printing a plausible-looking URL.
+ *
+ * Pure: no DOM, no Electron, no fetch. Takes the engine's own listClasses /
+ * listModels payloads and returns data; the toolbar paints it.
+ */
+
+/** Paths, as the transport spells them. Not templates — literal strings. */
+const POOLED_PATH = '/api/v1/chat/completions';
+const BYOK_PATH = '/api/v1/byok/chat/completions';
+const LOCAL_PATH = '/v1/chat/completions';
+const DEFAULT_CLOUD_BASE = 'https://aegiscloud.org';
+const DEFAULT_LOCAL_BASE = 'http://localhost:11434';
+
+/** Join a base and a path without doubling or dropping the separator. */
+function joinUrl(base, suffix) {
+  const b = typeof base === 'string' ? base.trim() : '';
+  const p = typeof suffix === 'string' ? suffix.trim() : '';
+  if (!b) return '';
+  // An absolute URL in the path slot wins: a deployment may publish a full
+  // base, and prefixing that with another base produces a URL that resolves to
+  // nothing while looking correct on screen.
+  if (/^https?:\/\//i.test(p)) return p;
+  if (!p) return b.replace(/\/+$/, '');
+  return `${b.replace(/\/+$/, '')}/${p.replace(/^\/+/, '')}`;
+}
+
+/**
+ * The billing line for a row. Read from what the engine already reported rather
+ * than assumed: a byok row's fee note only exists when the server publishes one
+ * (`fee.require_balance`), and saying "funded balance required" on a
+ * deployment that does not gate that way is the same lie pointing the other
+ * way (see engine.listModels' byok branch).
+ */
+function billingFor(cls, classRow, modelRow, listPayload) {
+  if (cls === 'pro') {
+    return 'Claude Code subscription — no AEGIS tokens spent';
+  }
+  if (cls === 'local') {
+    return 'free — runs on this machine';
+  }
+  if (cls === 'byok') {
+    const fee = (listPayload && listPayload.fee) || null;
+    if (fee && fee.require_balance) {
+      return 'your provider key pays the vendor; an AEGIS key and a funded balance pay the handling fee';
+    }
+    return 'your provider key pays the vendor; an AEGIS key attributes the handling fee';
+  }
+  // aegis (pooled): the account pays. No claim is made about which plan covers
+  // it — `configured` already says whether a key is present, and the Status
+  // card is where plan and balance actually live.
+  return 'billed to your AEGIS account';
+}
+
+/**
+ * Why a row cannot be used, or null when it can. Deliberately one short reason
+ * per row: the Model card's hint already carries the full remedy for the
+ * selected class, and duplicating that copy per row makes the list unreadable.
+ */
+function blockedReason(cls, classRow, modelRow, listPayload) {
+  if (cls === 'aegis' && listPayload && listPayload.needsKey) {
+    return 'no AEGIS API key on this machine';
+  }
+  if (cls === 'local' && listPayload && listPayload.needsDaemon) {
+    return 'no model server listening';
+  }
+  if (cls === 'local' && listPayload && listPayload.listed === false) {
+    return 'server answered but lists no models';
+  }
+  if (cls === 'byok' && modelRow && modelRow.configured === false) {
+    // The precise reason when the env file REFUSED a value it was given, rather
+    // than never having been given one — that distinction is the difference
+    // between "add a key" and "the key you added was rejected".
+    return modelRow.keyRejected
+      ? `provider key rejected: ${modelRow.keyRejected}`
+      : 'no key saved for this provider';
+  }
+  if (cls === 'pro' && classRow && classRow.configured === false) {
+    return 'not signed in to Claude Code';
+  }
+  return null;
+}
+
+/**
+ * One row per addressable model, in class order, plus a placeholder row for a
+ * class that offers no model list but is still a target (a pooled turn with no
+ * model pinned, a local daemon with nothing pulled yet).
+ *
+ * `rows` is `[{ class, classLabel, classConfigured, list }]`, where `list` is
+ * whatever `models.listModels(cls)` resolved to — including its error/state
+ * shape, so a class that failed to list still gets a row that says why.
+ */
+function buildProviderPaths(rows) {
+  const out = [];
+  const input = Array.isArray(rows) ? rows : [];
+  for (const r of input) {
+    if (!r || typeof r.class !== 'string') continue;
+    const cls = r.class;
+    const classRow = { configured: r.classConfigured !== false };
+    const list = r.list && typeof r.list === 'object' ? r.list : null;
+    const models = Array.isArray(list && list.models) ? list.models : [];
+    const cloudBase = (list && (list.apiBase || list.baseURL)) || DEFAULT_CLOUD_BASE;
+    const localBase = (list && list.baseURL) || DEFAULT_LOCAL_BASE;
+
+    if (!models.length) {
+      // No model row still means a real destination for two classes: the pooled
+      // class runs the server's default when nothing is pinned, and a local
+      // daemon with nothing pulled still answers on the same route once a tag
+      // is typed (engine.listModels' local branch). For byok and pro an empty
+      // list is genuinely "nothing to address", so only the reason is shown.
+      const placeholderOk = cls === 'aegis' || cls === 'local';
+      out.push({
+        class: cls,
+        classLabel: r.classLabel || cls,
+        model: '',
+        modelLabel:
+          cls === 'aegis'
+            ? 'server default (auto)'
+            : cls === 'local'
+              ? 'type a model tag in the Model card'
+              : '—',
+        provider: '',
+        uniqueModel: cls,
+        group: r.classLabel || cls,
+        url: placeholderOk
+          ? joinUrl(cls === 'local' ? localBase : cloudBase, cls === 'local' ? LOCAL_PATH : POOLED_PATH)
+          : null,
+        method: placeholderOk ? 'POST' : null,
+        billing: billingFor(cls, classRow, null, list),
+        blocked: blockedReason(cls, classRow, null, list),
+        // A row with no model id is not a selectable target: it is the class's
+        // own state, printed where its models would have gone.
+        selectable: false,
+      });
+      continue;
+    }
+
+    for (const m of models) {
+      if (!m || !m.id) continue;
+      const provider = typeof m.provider === 'string' && m.provider ? m.provider : cls;
+      let url = null;
+      let method = null;
+      if (cls === 'aegis') {
+        url = joinUrl(cloudBase, POOLED_PATH);
+        method = 'POST';
+      } else if (cls === 'byok') {
+        // The relay's route, INCLUDING for provider `custom`. That row looks
+        // like an exception and is not: this app never dials the user's own
+        // endpoint. It posts to the relay with `base_url` in the body and the
+        // server makes the outbound call (client/aegis.js byokChatCompletion,
+        // aegis1 `_byok_custom_base_url`). Printing the endpoint here would
+        // describe a connection no part of this client opens.
+        url = joinUrl(cloudBase, BYOK_PATH);
+        method = 'POST';
+      } else if (cls === 'local') {
+        url = joinUrl(localBase, LOCAL_PATH);
+        method = 'POST';
+      }
+      // cls === 'pro' leaves both null: it is a child process, not a route.
+      out.push({
+        class: cls,
+        classLabel: r.classLabel || cls,
+        model: m.id,
+        modelLabel: m.label || m.id,
+        provider,
+        uniqueModel: `${cls}:${m.id}`,
+        group: r.classLabel || cls,
+        url,
+        method,
+        billing: billingFor(cls, classRow, m, list),
+        blocked: blockedReason(cls, classRow, m, list),
+        selectable: true,
+      });
+    }
+  }
+  return out;
+}
+
+/**
+ * Case-insensitive substring match across everything a user might type: the
+ * model id, its label, the provider, the class, and the URL's host+path.
+ * Multi-term: every whitespace-separated term must match somewhere, so
+ * "anthropic sonnet" narrows instead of returning nothing.
+ */
+function filterEntries(entries, query) {
+  const list = Array.isArray(entries) ? entries : [];
+  const q = String(query == null ? '' : query).trim().toLowerCase();
+  if (!q) return list.slice();
+  const terms = q.split(/\s+/).filter(Boolean);
+  return list.filter((e) => {
+    const hay = [e.model, e.modelLabel, e.provider, e.class, e.classLabel, e.url || '']
+      .join('\n')
+      .toLowerCase();
+    return terms.every((t) => hay.includes(t));
+  });
+}
+
+/**
+ * The selection a row would produce, in the shape the Model card's own controls
+ * take: `{ class, model }` for the two <select>s. `model` is '' for a class
+ * whose picker offers the "auto" entry, which is exactly what selecting that
+ * option means today.
+ */
+function selectionFor(entry) {
+  if (!entry) return null;
+  return {
+    class: entry.class,
+    model: entry.class === 'aegis' && !entry.model ? '' : entry.model,
+  };
+}
+
+if (typeof module !== 'undefined' && module.exports) {
+  module.exports = {
+    buildProviderPaths,
+    filterEntries,
+    selectionFor,
+    joinUrl,
+    POOLED_PATH,
+    BYOK_PATH,
+    LOCAL_PATH,
+  };
+}