@7n/tauri-components 0.6.0 → 0.8.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@7n/tauri-components",
-  "version": "0.6.0",
+  "version": "0.8.0",
   "type": "module",
   "description": "Shared LLM agent engine + Vue/Quasar UI for Tauri apps (chat, journal, trust-tier approval).",
   "license": "MIT",
@@ -36,6 +36,8 @@
   "peerDependencies": {
     "@tauri-apps/api": "^2.0.0",
     "@tauri-apps/plugin-http": "^2.0.0",
+    "@tauri-apps/plugin-process": "^2.0.0",
+    "@tauri-apps/plugin-updater": "^2.0.0",
     "@vue/test-utils": "^2.0.0",
     "quasar": "^2.0.0",
     "vue": "^3.0.0"
@@ -43,6 +45,8 @@
   "peerDependenciesMeta": {
     "@tauri-apps/api": { "optional": true },
     "@tauri-apps/plugin-http": { "optional": true },
+    "@tauri-apps/plugin-process": { "optional": true },
+    "@tauri-apps/plugin-updater": { "optional": true },
     "@vue/test-utils": { "optional": true },
     "quasar": { "optional": true }
   },

package/src/core/resolve-omlx-base-url.js

@@ -0,0 +1,84 @@
+// Resolve the effective omlx base URL: when the myllm reverse proxy
+// (a Tauri app that forwards /v1/* to the real omlx server and logs every
+// request/response for its history view) is alive on its well-known local
+// port, route traffic through it; otherwise talk to omlx directly. The probe
+// hits {proxy origin}/health — the proxy forwards it to omlx itself, so a
+// 2xx proves BOTH the proxy and the upstream are up (omlx down behind a live
+// proxy yields 502 → direct). Framework-free so headless consumers (MCP
+// wrappers, node scripts) can reuse it; pass a Tauri fetch as fetchFn from
+// webview contexts to avoid CORS on localhost.
+
+export const DIRECT_OMLX_BASE_URL = 'http://127.0.0.1:8000/v1'
+export const PROXY_OMLX_BASE_URL = 'http://127.0.0.1:8088/v1'
+
+const DEFAULT_TIMEOUT_MS = 400
+const DEFAULT_TTL_MS = 12_000
+
+/**
+ * Is this URL the default local omlx server — the only target eligible for
+ * the proxy override? A user who deliberately pointed an app at another
+ * host/port must never be silently rerouted (the proxy's upstream is
+ * hardwired to the local :8000).
+ * @param {string} url candidate base URL
+ * @returns {boolean} true for 127.0.0.1:8000 / localhost:8000, false otherwise (incl. parse errors)
+ */
+export function isDirectOmlxUrl(url) {
+  try {
+    const { host } = new URL(url)
+    return host === '127.0.0.1:8000' || host === 'localhost:8000'
+  }
+  catch {
+    return false
+  }
+}
+
+/**
+ * One-shot probe: GET {proxy origin}/health with a short timeout. 2xx means
+ * the proxy (and omlx behind it) is alive → use the proxy; anything else
+ * (timeout, refused, 502) → use the direct URL.
+ * @param {{ directUrl?: string, proxyUrl?: string, fetchFn?: typeof fetch, timeoutMs?: number }} [params] config
+ * @returns {Promise<string>} the base URL to use
+ */
+export async function resolveOmlxBaseUrl({
+  directUrl = DIRECT_OMLX_BASE_URL,
+  proxyUrl = PROXY_OMLX_BASE_URL,
+  fetchFn = fetch,
+  timeoutMs = DEFAULT_TIMEOUT_MS,
+} = {}) {
+  try {
+    const healthUrl = new URL('/health', proxyUrl).toString()
+    const signal = typeof AbortSignal?.timeout === 'function' ? AbortSignal.timeout(timeoutMs) : undefined
+    const response = await fetchFn(healthUrl, { signal })
+    return response.ok ? proxyUrl : directUrl
+  }
+  catch {
+    return directUrl
+  }
+}
+
+// proxyUrl → { promise, expiresAt }. Caching the promise (not the value)
+// dedupes concurrent probes: several composables firing loadEnv() at once
+// trigger a single /health request.
+const cache = new Map()
+
+/**
+ * Cached {@link resolveOmlxBaseUrl}: at most one probe per proxyUrl per TTL
+ * window, so callers may resolve before every LLM call without paying the
+ * probe latency each time, while still noticing the proxy starting/stopping
+ * within one TTL.
+ * @param {{ directUrl?: string, proxyUrl?: string, fetchFn?: typeof fetch, timeoutMs?: number, ttlMs?: number, now?: () => number }} [params] config
+ * @returns {Promise<string>} the base URL to use
+ */
+export function resolveOmlxBaseUrlCached({ ttlMs = DEFAULT_TTL_MS, now = Date.now, ...probeOptions } = {}) {
+  const proxyUrl = probeOptions.proxyUrl ?? PROXY_OMLX_BASE_URL
+  const cached = cache.get(proxyUrl)
+  if (cached && now() < cached.expiresAt) return cached.promise
+  const promise = resolveOmlxBaseUrl(probeOptions)
+  cache.set(proxyUrl, { promise, expiresAt: now() + ttlMs })
+  return promise
+}
+
+/** Test hook: drop all cached probe results. */
+export function __resetOmlxBaseUrlCache() {
+  cache.clear()
+}

package/src/index.js

@@ -8,6 +8,7 @@ export { handleApprove, handleRequest, handleRespond } from './core/agent-handle
 export { createDispatch, validateInput } from './core/dispatch.js'
 export { createOpenAiChat, runAgent } from './core/llm.js'
 export { listOmlxModels, resolveModel } from './core/omlx-models.js'
+export { DIRECT_OMLX_BASE_URL, isDirectOmlxUrl, PROXY_OMLX_BASE_URL, resolveOmlxBaseUrl, resolveOmlxBaseUrlCached } from './core/resolve-omlx-base-url.js'
 export { listTools, toJsonSchema, toolManifest } from './core/manifest.js'
 export { classify, DEFAULT_ACTOR_TIERS, scopedManifest, scopedToolNames } from './core/scope.js'
 export { getTool } from './core/tools.js'

package/src/vue/index.js

@@ -5,5 +5,6 @@
 
 export { useAgent } from './use-agent.js'
 export { useOmlx } from './use-omlx.js'
+export { useUpdater } from './use-updater.js'
 export { createTauriJournalStore } from './journal-store-tauri.js'
 export { tauriTransport } from './transports.js'

package/src/vue/use-omlx.js

@@ -1,5 +1,7 @@
 import { ref } from 'vue'
 import { invoke } from '@tauri-apps/api/core'
+import { fetch as tauriFetch } from '@tauri-apps/plugin-http'
+import { isDirectOmlxUrl, resolveOmlxBaseUrlCached } from '../core/resolve-omlx-base-url.js'
 
 // Persisted config for the local omlx server (OpenAI-compatible MLX) that drives
 // the in-app agent. The API key / base URL come from Rust (omlx_config), which
@@ -9,6 +11,12 @@ import { invoke } from '@tauri-apps/api/core'
 // when localStorage is empty. Priority for base: localStorage > omlx_config >
 // hardcoded default. The key always comes from omlx_config.
 //
+// On top of that, when the resolved base is the default local :8000, loadEnv()
+// probes the myllm reverse proxy (:8088/health, cached with a short TTL) and
+// routes through it while it is alive — a runtime-only override that is never
+// persisted, so the dialog keeps showing/editing the direct URL and a custom
+// (non-:8000) base is never silently rerouted.
+//
 // storagePrefix namespaces the localStorage keys per app (so `task` and `mlmail`
 // keep independent base/model). defaults seed first launch.
 
@@ -70,10 +78,15 @@ export function useOmlx({ storagePrefix = 'agent', defaultBaseUrl = DEFAULT_BASE
     catch {
       return // not running under Tauri — keep localStorage / defaults
     }
-    if (!env) return
-    if (env.apiKey) apiKey.value = env.apiKey
-    if (env.baseUrl && !readStored(baseUrlKey)) baseUrl.value = env.baseUrl
-    if (env.model && !readStored(modelKey)) model.value = env.model
+    if (env) {
+      if (env.apiKey) apiKey.value = env.apiKey
+      if (env.baseUrl && !readStored(baseUrlKey)) baseUrl.value = env.baseUrl
+      if (env.model && !readStored(modelKey)) model.value = env.model
+    }
+    // myllm proxy override — only for the default local target, runtime-only.
+    if (isDirectOmlxUrl(baseUrl.value)) {
+      baseUrl.value = await resolveOmlxBaseUrlCached({ directUrl: baseUrl.value, fetchFn: tauriFetch })
+    }
   }
 
   /**

package/src/vue/use-updater.js

@@ -0,0 +1,116 @@
+import { onMounted, onUnmounted } from 'vue'
+import { relaunch } from '@tauri-apps/plugin-process'
+import { check } from '@tauri-apps/plugin-updater'
+import { useQuasar } from 'quasar'
+
+// Checks for an app update on mount and hourly thereafter, prompting via a
+// Quasar dialog; after install, offers an immediate relaunch. Requires the
+// host app's tauri.conf.json to configure plugins.updater (pubkey + endpoint)
+// and capabilities/default.json to grant "updater:default" — without the
+// capability, check() fails with a silent permission-denied that only surfaces
+// via console.error (no dialog, no visible error).
+//
+// No-op in dev builds: tauri.conf.json's version is the CI-injected release
+// version, not what's running locally, so the updater would always think dev
+// code is stale.
+
+const FIRST_CHECK_DELAY_MS = 3000
+const CHECK_INTERVAL_MS = 60 * 60 * 1000
+
+/**
+ * @returns {void}
+ */
+export function useUpdater() {
+  if (import.meta.env.DEV) return
+
+  const $q = useQuasar()
+  let timer = null
+  // A dialog is showing or an install already ran — don't stack background checks.
+  let busy = false
+
+  /**
+   * Asks the configured update endpoint for a newer version and, if found,
+   * walks the user through the install flow.
+   * @returns {Promise<void>}
+   */
+  async function checkForUpdates() {
+    if (busy) return
+    try {
+      const update = await check()
+      if (!update) return
+
+      busy = true
+      $q.dialog({
+        title: 'Доступне оновлення',
+        message: `Версія ${update.version} готова. Встановити зараз?`,
+        cancel: { label: 'Пізніше', flat: true },
+        ok: { label: 'Встановити', color: 'primary' },
+        persistent: true,
+      })
+        .onOk(() => installAndRelaunch(update))
+        .onCancel(() => {
+          busy = false
+        })
+    }
+    catch (error) {
+      // No network, or the updater isn't configured/permitted — don't bother
+      // the user, but leave a trace for diagnosis.
+      console.error('[updater] check failed:', error)
+    }
+  }
+
+  /**
+   * Downloads and installs the update with progress, then offers a relaunch.
+   * @param {import('@tauri-apps/plugin-updater').Update} update the update found by check()
+   * @returns {Promise<void>}
+   */
+  async function installAndRelaunch(update) {
+    let downloaded = 0
+    let total = 0
+    const dismiss = $q.notify({ group: false, timeout: 0, spinner: true, message: 'Завантаження оновлення…' })
+    try {
+      await update.downloadAndInstall(event => {
+        switch (event.event) {
+          case 'Started': {
+            total = event.data.contentLength ?? 0
+            break
+          }
+          case 'Progress': {
+            downloaded += event.data.chunkLength
+            if (total) dismiss({ message: `Завантаження… ${Math.round((downloaded / total) * 100)}%` })
+            break
+          }
+          case 'Finished': {
+            dismiss()
+            break
+          }
+          // No default
+        }
+      })
+      // busy stays true: the update is already on disk, a repeat check would
+      // only offer to install the same thing again.
+      $q.dialog({
+        title: 'Оновлення встановлено',
+        message: `Перезапустити зараз, щоб перейти на версію ${update.version}?`,
+        cancel: { label: 'Пізніше', flat: true },
+        ok: { label: 'Перезапустити', color: 'primary' },
+        persistent: true,
+      }).onOk(() => relaunch())
+    }
+    catch (error) {
+      dismiss()
+      busy = false
+      console.error('[updater] install failed:', error)
+      $q.notify({ message: `Помилка оновлення: ${error}`, color: 'negative', timeout: 5000 })
+    }
+  }
+
+  onMounted(() => {
+    setTimeout(checkForUpdates, FIRST_CHECK_DELAY_MS)
+    timer = setInterval(checkForUpdates, CHECK_INTERVAL_MS)
+  })
+
+  onUnmounted(() => {
+    if (timer) clearInterval(timer)
+  })
+}

package/types/core/resolve-omlx-base-url.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Is this URL the default local omlx server — the only target eligible for
+ * the proxy override? A user who deliberately pointed an app at another
+ * host/port must never be silently rerouted (the proxy's upstream is
+ * hardwired to the local :8000).
+ * @param {string} url candidate base URL
+ * @returns {boolean} true for 127.0.0.1:8000 / localhost:8000, false otherwise (incl. parse errors)
+ */
+export function isDirectOmlxUrl(url: string): boolean;
+/**
+ * One-shot probe: GET {proxy origin}/health with a short timeout. 2xx means
+ * the proxy (and omlx behind it) is alive → use the proxy; anything else
+ * (timeout, refused, 502) → use the direct URL.
+ * @param {{ directUrl?: string, proxyUrl?: string, fetchFn?: typeof fetch, timeoutMs?: number }} [params] config
+ * @returns {Promise<string>} the base URL to use
+ */
+export function resolveOmlxBaseUrl({ directUrl, proxyUrl, fetchFn, timeoutMs, }?: {
+    directUrl?: string;
+    proxyUrl?: string;
+    fetchFn?: typeof fetch;
+    timeoutMs?: number;
+}): Promise<string>;
+/**
+ * Cached {@link resolveOmlxBaseUrl}: at most one probe per proxyUrl per TTL
+ * window, so callers may resolve before every LLM call without paying the
+ * probe latency each time, while still noticing the proxy starting/stopping
+ * within one TTL.
+ * @param {{ directUrl?: string, proxyUrl?: string, fetchFn?: typeof fetch, timeoutMs?: number, ttlMs?: number, now?: () => number }} [params] config
+ * @returns {Promise<string>} the base URL to use
+ */
+export function resolveOmlxBaseUrlCached({ ttlMs, now, ...probeOptions }?: {
+    directUrl?: string;
+    proxyUrl?: string;
+    fetchFn?: typeof fetch;
+    timeoutMs?: number;
+    ttlMs?: number;
+    now?: () => number;
+}): Promise<string>;
+/** Test hook: drop all cached probe results. */
+export function __resetOmlxBaseUrlCache(): void;
+export const DIRECT_OMLX_BASE_URL: "http://127.0.0.1:8000/v1";
+export const PROXY_OMLX_BASE_URL: "http://127.0.0.1:8088/v1";

package/types/index.d.ts

@@ -4,5 +4,6 @@ export { handleApprove, handleRequest, handleRespond } from "./core/agent-handle
 export { createDispatch, validateInput } from "./core/dispatch.js";
 export { createOpenAiChat, runAgent } from "./core/llm.js";
 export { listOmlxModels, resolveModel } from "./core/omlx-models.js";
+export { DIRECT_OMLX_BASE_URL, isDirectOmlxUrl, PROXY_OMLX_BASE_URL, resolveOmlxBaseUrl, resolveOmlxBaseUrlCached } from "./core/resolve-omlx-base-url.js";
 export { listTools, toJsonSchema, toolManifest } from "./core/manifest.js";
 export { classify, DEFAULT_ACTOR_TIERS, scopedManifest, scopedToolNames } from "./core/scope.js";