onbuzz 4.6.2 → 4.7.0

package/src/utilities/__tests__/secretsCipher.test.js

@@ -0,0 +1,97 @@
+/**
+ * Tests for the shared cipher primitives used by both
+ * `services/apiKeyManager.js` (api-keys.enc) and
+ * `services/authCacheStore.js` (auth-cache.enc).
+ *
+ * Covers:
+ *   - key derivation: persistence across calls, identity vs different salts
+ *   - round-trip: encrypt then decrypt returns the original
+ *   - constants stability: KEY_DERIVATION_DOMAIN is part of the on-disk
+ *     contract and must not change without a migration
+ */
+
+import { describe, test, expect, beforeEach, afterEach } from '@jest/globals';
+import { promises as fs } from 'fs';
+import path from 'path';
+import os from 'os';
+import crypto from 'crypto';
+
+import {
+  encrypt,
+  decrypt,
+  getOrCreateEncryptionKey,
+  KEY_DERIVATION_DOMAIN,
+  SALT_FILENAME,
+  SALT_LENGTH,
+  KEY_LENGTH,
+} from '../secretsCipher.js';
+
+const tmpDir = path.join(os.tmpdir(), 'secretsCipher-test-' + crypto.randomBytes(6).toString('hex'));
+
+beforeEach(async () => { await fs.mkdir(tmpDir, { recursive: true }); });
+afterEach(async () => { try { await fs.rm(tmpDir, { recursive: true, force: true }); } catch { /* ok */ } });
+
+describe('secretsCipher', () => {
+  test('KEY_DERIVATION_DOMAIN is the documented value — changing this invalidates all stored credentials', () => {
+    // Tripwire: this constant is part of the on-disk contract.
+    // If you intentionally need to rotate it, also write a migration.
+    expect(KEY_DERIVATION_DOMAIN).toBe('loxia-api-key-encryption-v1');
+  });
+
+  test('getOrCreateEncryptionKey creates a salt file on first call', async () => {
+    await getOrCreateEncryptionKey(tmpDir, null);
+    const saltFile = path.join(tmpDir, SALT_FILENAME);
+    const buf = await fs.readFile(saltFile);
+    expect(buf.length).toBe(SALT_LENGTH);
+  });
+
+  test('getOrCreateEncryptionKey reuses the existing salt on subsequent calls', async () => {
+    const key1 = await getOrCreateEncryptionKey(tmpDir, null);
+    const key2 = await getOrCreateEncryptionKey(tmpDir, null);
+    expect(key1.equals(key2)).toBe(true);
+    expect(key1.length).toBe(KEY_LENGTH);
+  });
+
+  test('different salt directories yield different keys', async () => {
+    const dirA = path.join(tmpDir, 'a');
+    const dirB = path.join(tmpDir, 'b');
+    await fs.mkdir(dirA); await fs.mkdir(dirB);
+    const keyA = await getOrCreateEncryptionKey(dirA, null);
+    const keyB = await getOrCreateEncryptionKey(dirB, null);
+    expect(keyA.equals(keyB)).toBe(false);
+  });
+
+  test('encrypt then decrypt round-trips the plaintext', async () => {
+    const key = await getOrCreateEncryptionKey(tmpDir, null);
+    const plaintext = JSON.stringify({ jwt: 'eyJ.test.jwt', user: { id: 'u-1' } });
+    const ct = encrypt(plaintext, key);
+    expect(typeof ct).toBe('string');
+    expect(ct).not.toContain('eyJ');     // not plaintext
+    expect(decrypt(ct, key)).toBe(plaintext);
+  });
+
+  test('encrypt produces different ciphertext each call (random IV)', async () => {
+    const key = await getOrCreateEncryptionKey(tmpDir, null);
+    const ct1 = encrypt('same', key);
+    const ct2 = encrypt('same', key);
+    expect(ct1).not.toBe(ct2);
+  });
+
+  test('decrypt throws with a clear message when no key supplied', () => {
+    expect(() => decrypt('anything', null)).toThrow('Encryption key not initialized');
+  });
+
+  test('encrypt throws with a clear message when no key supplied', () => {
+    expect(() => encrypt('anything', null)).toThrow('Encryption key not initialized');
+  });
+
+  test('decrypt fails on tampered ciphertext (GCM authTag check)', async () => {
+    const key = await getOrCreateEncryptionKey(tmpDir, null);
+    const ct = encrypt('payload', key);
+    // Flip a byte in the middle of the buffer
+    const buf = Buffer.from(ct, 'base64');
+    buf[Math.floor(buf.length / 2)] ^= 0xff;
+    const tampered = buf.toString('base64');
+    expect(() => decrypt(tampered, key)).toThrow();
+  });
+});

package/src/utilities/__tests__/updateNotifier.test.js

@@ -0,0 +1,139 @@
+/**
+ * Tests for src/utilities/updateNotifier.js — the CLI banner wrapper.
+ *
+ * The helper has four kill-switch paths and two normal paths. We
+ * test each so a regression doesn't either spam users or silently
+ * stop checking.
+ */
+
+import { describe, test, expect, jest } from '@jest/globals';
+import {
+  runUpdateCheck,
+  isUpdateCheckDisabled,
+  loadPackageJson,
+} from '../updateNotifier.js';
+
+describe('isUpdateCheckDisabled', () => {
+  test('returns false on an empty env', () => {
+    expect(isUpdateCheckDisabled({})).toBe(false);
+  });
+
+  test('honors LOXIA_DISABLE_UPDATE_CHECK', () => {
+    expect(isUpdateCheckDisabled({ LOXIA_DISABLE_UPDATE_CHECK: '1' })).toBe(true);
+    expect(isUpdateCheckDisabled({ LOXIA_DISABLE_UPDATE_CHECK: 'true' })).toBe(true);
+  });
+
+  test('honors NO_UPDATE_NOTIFIER (package convention)', () => {
+    expect(isUpdateCheckDisabled({ NO_UPDATE_NOTIFIER: '1' })).toBe(true);
+  });
+
+  test('honors CI=true (avoids banner in pipelines)', () => {
+    expect(isUpdateCheckDisabled({ CI: 'true' })).toBe(true);
+  });
+
+  test('treats "0" and "false" as not-disabled (escape hatch for misuse)', () => {
+    expect(isUpdateCheckDisabled({ LOXIA_DISABLE_UPDATE_CHECK: '0' })).toBe(false);
+    expect(isUpdateCheckDisabled({ LOXIA_DISABLE_UPDATE_CHECK: 'false' })).toBe(false);
+  });
+});
+
+describe('loadPackageJson', () => {
+  test('finds the CLI package.json by walking up from a starting dir', () => {
+    // The helper looks for a pkg.json with `bin` OR `@loxia-labs/` name —
+    // both true of this repo's root pkg.json.
+    const pkg = loadPackageJson();
+    expect(pkg).not.toBeNull();
+    expect(pkg.name).toMatch(/loxia/i);
+    expect(typeof pkg.version).toBe('string');
+  });
+
+  test('returns null when no qualifying package.json exists in the chain', () => {
+    // Inject a stub that always returns ENOENT.
+    const fs = {
+      readFileSync: () => { throw Object.assign(new Error('nope'), { code: 'ENOENT' }); },
+    };
+    expect(loadPackageJson({ startDir: '/tmp', fs })).toBeNull();
+  });
+});
+
+describe('runUpdateCheck — kill-switches', () => {
+  test('returns null when disabled by env', async () => {
+    const importImpl = jest.fn();
+    const r = await runUpdateCheck({
+      env: { LOXIA_DISABLE_UPDATE_CHECK: '1' },
+      pkg: { name: 'x', version: '1.0.0' },
+      importImpl,
+    });
+    expect(r).toBeNull();
+    expect(importImpl).not.toHaveBeenCalled();
+  });
+
+  test('returns null when pkg.json could not be loaded', async () => {
+    const importImpl = jest.fn();
+    const r = await runUpdateCheck({
+      env: {},
+      pkg: null,
+      importImpl,
+    });
+    expect(r).toBeNull();
+    expect(importImpl).not.toHaveBeenCalled();
+  });
+});
+
+describe('runUpdateCheck — dependency tolerance', () => {
+  test('returns null when update-notifier is not installed', async () => {
+    const importImpl = jest.fn().mockRejectedValue(new Error('Cannot find module'));
+    const r = await runUpdateCheck({
+      env: {},
+      pkg: { name: 'x', version: '1.0.0' },
+      importImpl,
+    });
+    expect(r).toBeNull();
+  });
+
+  test('returns null when the module exists but has the wrong shape', async () => {
+    const importImpl = jest.fn().mockResolvedValue({ /* no default, no callable */ });
+    const r = await runUpdateCheck({
+      env: {},
+      pkg: { name: 'x', version: '1.0.0' },
+      importImpl,
+    });
+    expect(r).toBeNull();
+  });
+});
+
+describe('runUpdateCheck — happy path', () => {
+  test('invokes update-notifier with the supplied pkg and calls notify()', async () => {
+    const notifyMock = jest.fn();
+    const updateNotifierFn = jest.fn().mockReturnValue({ notify: notifyMock });
+    const importImpl = jest.fn().mockResolvedValue({ default: updateNotifierFn });
+
+    const pkg = { name: '@loxia-labs/loxia-autopilot-one', version: '4.6.4' };
+    const result = await runUpdateCheck({ env: {}, pkg, importImpl });
+
+    expect(result).toEqual({ notify: notifyMock });
+    expect(updateNotifierFn).toHaveBeenCalledTimes(1);
+    const call = updateNotifierFn.mock.calls[0][0];
+    expect(call.pkg).toBe(pkg);
+    expect(typeof call.updateCheckInterval).toBe('number');
+    expect(notifyMock).toHaveBeenCalledTimes(1);
+
+    const notifyOpts = notifyMock.mock.calls[0][0];
+    expect(notifyOpts.isGlobal).toBe(true);
+    expect(notifyOpts.message).toContain('{packageName}');
+  });
+
+  test('a throwing notifier does not surface — returns null', async () => {
+    const updateNotifierFn = jest.fn().mockImplementation(() => { throw new Error('boom'); });
+    const importImpl = jest.fn().mockResolvedValue({ default: updateNotifierFn });
+    const logger = { debug: jest.fn() };
+    const r = await runUpdateCheck({
+      env: {},
+      pkg: { name: 'x', version: '1.0.0' },
+      importImpl,
+      logger,
+    });
+    expect(r).toBeNull();
+    expect(logger.debug).toHaveBeenCalled();
+  });
+});

package/src/utilities/authCache.js

@@ -0,0 +1,121 @@
+/**
+ * Auth-result cache shape + transitions.
+ *
+ * The webServer caches the most recent auth event in `lastAuthResult` so
+ * a frontend that missed the WS broadcast (page reload, dropped
+ * connection, race) can recover via polling `/api/auth/status`. The
+ * cache shape and three state transitions live here so they're
+ * testable without standing up Express.
+ *
+ * Cache shape:
+ *   { user, hasApiKey, jwt, timestamp }
+ *
+ *   - user       — { id, email, ... } or null
+ *   - hasApiKey  — bool
+ *   - jwt        — raw bearer token from OAuth, or null. Mandatory for
+ *                  marketplace publish/install/rate calls (the marketplace
+ *                  service verifies JWTs directly, not lx_* keys).
+ *   - timestamp  — ISO of when this cache row was written; used for
+ *                  staleness checks via `?since=` polling.
+ *
+ * Bug history this guards against:
+ *   - 2026-05: marketplace publish 401 "Authentication required" because
+ *     OAuth callback cached only {user, hasApiKey, timestamp} without
+ *     the JWT, then a page reload triggered the polling fallback which
+ *     returned the user but no JWT. The FE thought "I'm signed in" but
+ *     localStorage.loxia-auth-token stayed empty → no Bearer header on
+ *     marketplace calls → 401.
+ */
+
+/**
+ * Build a cache row for a successful OAuth callback. The JWT is the
+ * critical field — without it, the polling fallback can't restore
+ * marketplace auth on a refresh.
+ *
+ * @param {Object} input
+ * @param {Object} input.user      - User account object
+ * @param {string|null} input.jwt  - Raw JWT from the OAuth callback
+ * @param {boolean} input.hasApiKey
+ * @param {string} [input.timestamp] - Override (for tests); defaults to now
+ * @returns {Object} cache row
+ */
+export function recordOAuthResult({ user, jwt, hasApiKey, timestamp } = {}) {
+  return {
+    user: user || null,
+    hasApiKey: !!hasApiKey,
+    jwt: typeof jwt === 'string' && jwt.length > 0 ? jwt : null,
+    timestamp: timestamp || new Date().toISOString(),
+  };
+}
+
+/**
+ * Build a cache row when a user is resolved from an API key alone (no
+ * OAuth event, so no JWT minted in this flow). PRESERVES any JWT from
+ * a previous OAuth login — overwriting `lastAuthResult` with no `jwt`
+ * field would silently wipe marketplace auth for users who hit
+ * /auth/resolve after /auth/callback.
+ *
+ * @param {Object} input
+ * @param {Object} input.user
+ * @param {Object|null} input.prevCache - previous lastAuthResult
+ * @param {string} [input.timestamp]
+ * @returns {Object} cache row
+ */
+export function recordResolvedUser({ user, prevCache, timestamp } = {}) {
+  const carriedJwt = prevCache && typeof prevCache.jwt === 'string' && prevCache.jwt.length > 0
+    ? prevCache.jwt
+    : null;
+  return {
+    user: user || null,
+    hasApiKey: true,                        // resolve path requires an API key
+    jwt: carriedJwt,
+    timestamp: timestamp || new Date().toISOString(),
+  };
+}
+
+/**
+ * Project a cache row into the JSON the `/api/auth/status` endpoint
+ * returns. Implements two pieces of business logic:
+ *
+ *   1. Staleness gate via `?since=`: if the caller is polling for an
+ *      auth event AFTER a known timestamp, but the cache row predates
+ *      that timestamp, the row is considered "not the auth we're
+ *      waiting for" and the user is reported as null. Prevents a
+ *      previously-cached login from masquerading as the in-flight one.
+ *
+ *   2. JWT only flows out when a fresh user is reported. When `user`
+ *      is null (no cached row, or stale), `jwt` is also null — the
+ *      pair is always coherent so the FE never sees user=null with
+ *      jwt=<something>.
+ *
+ * @param {Object|null} cache - lastAuthResult value
+ * @param {Object} [options]
+ * @param {string} [options.since] - ISO timestamp from the caller
+ * @param {boolean} [options.hasApiKey] - hasApiKey value at request time
+ *   (cache.hasApiKey is the value AT CACHE TIME — the live answer comes
+ *   from the apiKeyManager). The route passes the live one in.
+ * @returns {{ success: true, authenticated: boolean, user: Object|null, jwt: string|null, timestamp: string|null }}
+ */
+export function projectAuthStatus(cache, options = {}) {
+  const since = options.since;
+  const liveHasApiKey = options.hasApiKey === undefined ? !!cache?.hasApiKey : !!options.hasApiKey;
+
+  let user = cache?.user || null;
+  if (since && cache?.timestamp) {
+    if (new Date(cache.timestamp).getTime() <= new Date(since).getTime()) {
+      // Cache predates the login attempt the caller is polling for.
+      user = null;
+    }
+  }
+
+  // Pair invariant: jwt is null whenever user is null.
+  const jwt = user ? (cache?.jwt || null) : null;
+
+  return {
+    success: true,
+    authenticated: liveHasApiKey,
+    user,
+    jwt,
+    timestamp: cache?.timestamp || null,
+  };
+}

package/src/utilities/secretsCipher.js

@@ -0,0 +1,116 @@
+/**
+ * Shared encryption primitives for at-rest credential storage.
+ *
+ * Used by:
+ *   - services/apiKeyManager.js   (api-keys.enc)
+ *   - services/authCacheStore.js  (auth-cache.enc)
+ *
+ * Both stores derive the same machine-specific AES-256-GCM key from a
+ * persistent salt at `<userDataDir>/.key-salt` plus os-derived data.
+ * Sharing the cipher primitives keeps the byte layout consistent and
+ * means a single review covers credential-at-rest for the whole app.
+ *
+ * On-disk format (per ciphertext, base64-encoded):
+ *   [ IV (16B) | authTag (16B) | ciphertext (variable) ]
+ *
+ * KEY_DERIVATION_DOMAIN must stay constant — changing it invalidates
+ * every existing `api-keys.enc` on every user's machine.
+ */
+
+import crypto from 'crypto';
+import os from 'os';
+import path from 'path';
+import { promises as fs } from 'fs';
+
+export const ALGORITHM = 'aes-256-gcm';
+export const KEY_LENGTH = 32;        // 256 bits
+export const IV_LENGTH = 16;
+export const AUTH_TAG_LENGTH = 16;
+export const SALT_LENGTH = 32;
+export const PBKDF2_ITERATIONS = 100000;
+export const SALT_FILENAME = '.key-salt';
+
+/**
+ * Domain-separation string mixed into the key derivation input. Must
+ * not change without a migration — existing on-disk files would
+ * become undecryptable.
+ */
+export const KEY_DERIVATION_DOMAIN = 'loxia-api-key-encryption-v1';
+
+/**
+ * Read or create the per-machine salt and derive the AES key from it
+ * combined with stable machine identifiers.
+ *
+ * @param {string} settingsDir - directory holding `.key-salt`
+ * @param {Object} [logger]
+ * @returns {Promise<Buffer>} 32-byte AES key
+ */
+export async function getOrCreateEncryptionKey(settingsDir, logger) {
+  const saltFile = path.join(settingsDir, SALT_FILENAME);
+  let salt;
+  try {
+    salt = await fs.readFile(saltFile);
+  } catch {
+    salt = crypto.randomBytes(SALT_LENGTH);
+    await fs.writeFile(saltFile, salt, { mode: 0o600 });
+    logger?.info?.('[secretsCipher] Generated new encryption salt');
+  }
+
+  const machineData = [
+    os.hostname(),
+    os.homedir(),
+    os.userInfo().username,
+    process.platform,
+    KEY_DERIVATION_DOMAIN,
+  ].join(':');
+
+  return crypto.pbkdf2Sync(machineData, salt, PBKDF2_ITERATIONS, KEY_LENGTH, 'sha256');
+}
+
+/**
+ * Encrypt a UTF-8 plaintext to a base64 string carrying IV+authTag.
+ *
+ * @param {string} plaintext
+ * @param {Buffer} encryptionKey
+ * @returns {string} base64
+ */
+export function encrypt(plaintext, encryptionKey) {
+  if (!encryptionKey) throw new Error('Encryption key not initialized');
+
+  const iv = crypto.randomBytes(IV_LENGTH);
+  const cipher = crypto.createCipheriv(ALGORITHM, encryptionKey, iv);
+
+  let encrypted = cipher.update(plaintext, 'utf8', 'base64');
+  encrypted += cipher.final('base64');
+
+  const authTag = cipher.getAuthTag();
+  const combined = Buffer.concat([
+    iv,
+    authTag,
+    Buffer.from(encrypted, 'base64'),
+  ]);
+  return combined.toString('base64');
+}
+
+/**
+ * Decrypt a base64 IV+authTag+ciphertext blob back to UTF-8.
+ *
+ * @param {string} encryptedData base64
+ * @param {Buffer} encryptionKey
+ * @returns {string} plaintext
+ */
+export function decrypt(encryptedData, encryptionKey) {
+  if (!encryptionKey) throw new Error('Encryption key not initialized');
+
+  const combined = Buffer.from(encryptedData, 'base64');
+  const iv = combined.subarray(0, IV_LENGTH);
+  const authTag = combined.subarray(IV_LENGTH, IV_LENGTH + AUTH_TAG_LENGTH);
+  const encrypted = combined.subarray(IV_LENGTH + AUTH_TAG_LENGTH);
+
+  const decipher = crypto.createDecipheriv(ALGORITHM, encryptionKey, iv);
+  decipher.setAuthTag(authTag);
+
+  let decrypted = decipher.update(encrypted.toString('base64'), 'base64', 'utf8');
+  decrypted += decipher.final('utf8');
+  return decrypted;
+}

package/src/utilities/updateNotifier.js

@@ -0,0 +1,140 @@
+/**
+ * npm CLI update notifier — thin wrapper around `update-notifier`.
+ *
+ * Shows a non-blocking banner on CLI startup when a newer version of
+ * the published package is available on the npm registry. User stays
+ * in control: the CLI never auto-installs anything.
+ *
+ * Brand awareness:
+ *   The CLI ships under two brand-specific package names
+ *   (`@loxia-labs/loxia-autopilot-one`, `@loxia-labs/loxia-onbuzz`).
+ *   `update-notifier` reads the package name from the runtime
+ *   package.json so each brand's notifier checks the right registry
+ *   entry automatically.
+ *
+ * Kill-switch:
+ *   - LOXIA_DISABLE_UPDATE_CHECK=1   — our env var (preferred)
+ *   - NO_UPDATE_NOTIFIER=1           — package's own opt-out
+ *   - CI=true                        — most CIs set this; we honour it
+ *
+ * Dependency tolerance:
+ *   `update-notifier` is dynamically imported. If the package isn't
+ *   installed (e.g. dev tree without `npm install`), the function is
+ *   a silent no-op — the CLI MUST still boot.
+ *
+ * Network tolerance:
+ *   The check is a background fetch with cached result. We never await
+ *   the network — `update-notifier` schedules a child-process fetch
+ *   and writes the result to ~/.config/configstore for the NEXT run.
+ *   That means: the FIRST time a user is offline, no banner. Subsequent
+ *   runs use the cached version-comparison until the next check window.
+ */
+
+import { readFileSync } from 'fs';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+
+/**
+ * Env vars that disable the check. All are case-sensitive string
+ * comparisons against `'1'` / `'true'` to match common conventions.
+ */
+const DISABLE_ENVS = Object.freeze([
+  'LOXIA_DISABLE_UPDATE_CHECK',
+  'NO_UPDATE_NOTIFIER',
+  'CI',                       // standard CI marker
+]);
+
+/** How often update-notifier should re-check the npm registry. */
+const UPDATE_CHECK_INTERVAL_MS = 1000 * 60 * 60 * 24; // 24h
+
+/**
+ * @returns {boolean} true if any kill-switch env is set truthy.
+ */
+export function isUpdateCheckDisabled(env = process.env) {
+  for (const key of DISABLE_ENVS) {
+    const v = env[key];
+    if (v && v !== '0' && v.toLowerCase() !== 'false') return true;
+  }
+  return false;
+}
+
+/**
+ * Load the package.json this CLI is running from (the installed one,
+ * not the one in src/utilities of a dev tree). Returned object always
+ * has at least `name` and `version`.
+ *
+ * @returns {{ name: string, version: string } | null}
+ */
+export function loadPackageJson({
+  startDir = dirname(fileURLToPath(import.meta.url)),
+  fs = { readFileSync },
+} = {}) {
+  // Walk up from this file looking for package.json with a `bin`
+  // entry — that's the published CLI package, not a nested dep.
+  let dir = startDir;
+  const ROOT_LIMIT = 8;
+  for (let i = 0; i < ROOT_LIMIT; i++) {
+    try {
+      const raw = fs.readFileSync(join(dir, 'package.json'), 'utf8');
+      const pkg = JSON.parse(raw);
+      if (pkg.bin || pkg.name?.startsWith('@loxia-labs/')) {
+        return { name: pkg.name, version: pkg.version };
+      }
+    } catch { /* keep walking */ }
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+
+/**
+ * Run the update check and (if a newer version is on the registry)
+ * print a banner. Never throws. Never blocks. Safe to call exactly
+ * once at CLI entry.
+ *
+ * Returns the underlying notifier instance for tests, or null when
+ * disabled / package missing / pkg.json unreadable.
+ */
+export async function runUpdateCheck({
+  env = process.env,
+  pkg = loadPackageJson(),
+  importImpl = (specifier) => import(specifier),
+  logger = console,
+} = {}) {
+  if (isUpdateCheckDisabled(env)) return null;
+  if (!pkg) return null;
+
+  let mod;
+  try {
+    mod = await importImpl('update-notifier');
+  } catch {
+    // Package not installed in this tree. Silent no-op.
+    return null;
+  }
+
+  const updateNotifier = mod.default || mod;
+  if (typeof updateNotifier !== 'function') return null;
+
+  try {
+    const notifier = updateNotifier({
+      pkg,
+      updateCheckInterval: UPDATE_CHECK_INTERVAL_MS,
+      shouldNotifyInNpmScript: false,
+    });
+    // notify() is itself a no-op when there's no update; safe to call
+    // unconditionally.
+    notifier.notify?.({
+      defer: false,            // print before the CLI does its work
+      isGlobal: true,          // CLI ships as a global binary
+      message:
+        `Update available {currentVersion} → {latestVersion}\n` +
+        `Run \`npm i -g {packageName}\` to update.`,
+    });
+    return notifier;
+  } catch (err) {
+    // Any failure (network, configstore write, etc.) is non-fatal.
+    logger?.debug?.('[updateNotifier] check skipped:', err.message);
+    return null;
+  }
+}

package/web-ui/build/index.html

@@ -6,8 +6,8 @@
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>Loxia Autopilot One</title>
     <meta name="description" content="AI Agents System - No-code/vibe-code/companion-coder platform" />
-    <script type="module" crossorigin src="/static/index-CLelJq9j.js"></script>
-    <link rel="stylesheet" crossorigin href="/static/index-f5UnFSsY.css">
+    <script type="module" crossorigin src="/static/index-Be9WvMkI.js"></script>
+    <link rel="stylesheet" crossorigin href="/static/index-Cr9q1fNq.css">
   </head>
   <body>
     <div id="root"></div>

package/web-ui/build/static/1c-D_MLuenD.js

@@ -0,0 +1 @@
+import{g as f}from"./index-Be9WvMkI.js";import{r as s}from"./index-CuZ_erP9.js";function i(t,n){for(var o=0;o<n.length;o++){const e=n[o];if(typeof e!="string"&&!Array.isArray(e)){for(const r in e)if(r!=="default"&&!(r in t)){const c=Object.getOwnPropertyDescriptor(e,r);c&&Object.defineProperty(t,r,c.get?c:{enumerable:!0,get:()=>e[r]})}}}return Object.freeze(Object.defineProperty(t,Symbol.toStringTag,{value:"Module"}))}var a=s();const p=f(a),l=i({__proto__:null,default:p},[a]);export{l as _};

package/web-ui/build/static/abap-BNvFMksw.js

@@ -0,0 +1 @@
+import{g as s,r as f}from"./index-Be9WvMkI.js";function c(t,n){for(var o=0;o<n.length;o++){const e=n[o];if(typeof e!="string"&&!Array.isArray(e)){for(const r in e)if(r!=="default"&&!(r in t)){const a=Object.getOwnPropertyDescriptor(e,r);a&&Object.defineProperty(t,r,a.get?a:{enumerable:!0,get:()=>e[r]})}}}return Object.freeze(Object.defineProperty(t,Symbol.toStringTag,{value:"Module"}))}var p=f();const i=s(p),b=c({__proto__:null,default:i},[p]);export{b as a};

package/web-ui/build/static/abnf-WlnRJIp2.js

@@ -0,0 +1 @@
+import{g as s}from"./index-Be9WvMkI.js";import{a as i}from"./index-CuZ_erP9.js";function c(t,n){for(var o=0;o<n.length;o++){const e=n[o];if(typeof e!="string"&&!Array.isArray(e)){for(const r in e)if(r!=="default"&&!(r in t)){const a=Object.getOwnPropertyDescriptor(e,r);a&&Object.defineProperty(t,r,a.get?a:{enumerable:!0,get:()=>e[r]})}}}return Object.freeze(Object.defineProperty(t,Symbol.toStringTag,{value:"Module"}))}var f=i();const p=s(f),g=c({__proto__:null,default:p},[f]);export{g as a};

package/web-ui/build/static/abnf-mx1Wbtnp.js

@@ -0,0 +1 @@
+import{g as s,d as c}from"./index-Be9WvMkI.js";function i(t,a){for(var o=0;o<a.length;o++){const e=a[o];if(typeof e!="string"&&!Array.isArray(e)){for(const r in e)if(r!=="default"&&!(r in t)){const n=Object.getOwnPropertyDescriptor(e,r);n&&Object.defineProperty(t,r,n.get?n:{enumerable:!0,get:()=>e[r]})}}}return Object.freeze(Object.defineProperty(t,Symbol.toStringTag,{value:"Module"}))}var f=c();const p=s(f),b=i({__proto__:null,default:p},[f]);export{b as a};

package/web-ui/build/static/accesslog-CJumJuuV.js

@@ -0,0 +1 @@
+import{g as n}from"./index-Be9WvMkI.js";import{b as f}from"./index-CuZ_erP9.js";function g(t,c){for(var o=0;o<c.length;o++){const e=c[o];if(typeof e!="string"&&!Array.isArray(e)){for(const r in e)if(r!=="default"&&!(r in t)){const s=Object.getOwnPropertyDescriptor(e,r);s&&Object.defineProperty(t,r,s.get?s:{enumerable:!0,get:()=>e[r]})}}}return Object.freeze(Object.defineProperty(t,Symbol.toStringTag,{value:"Module"}))}var a=f();const l=n(a),u=g({__proto__:null,default:l},[a]);export{u as a};

package/web-ui/build/static/actionscript-B6CbK7n7.js

@@ -0,0 +1 @@
+import{g as a,e as s}from"./index-Be9WvMkI.js";function p(r,i){for(var o=0;o<i.length;o++){const t=i[o];if(typeof t!="string"&&!Array.isArray(t)){for(const e in t)if(e!=="default"&&!(e in r)){const c=Object.getOwnPropertyDescriptor(t,e);c&&Object.defineProperty(r,e,c.get?c:{enumerable:!0,get:()=>t[e]})}}}return Object.freeze(Object.defineProperty(r,Symbol.toStringTag,{value:"Module"}))}var n=s();const f=a(n),g=p({__proto__:null,default:f},[n]);export{g as a};

package/web-ui/build/static/actionscript-DZ5xfmPr.js

@@ -0,0 +1 @@
+import{g as a}from"./index-Be9WvMkI.js";import{c as s}from"./index-CuZ_erP9.js";function p(r,i){for(var o=0;o<i.length;o++){const t=i[o];if(typeof t!="string"&&!Array.isArray(t)){for(const e in t)if(e!=="default"&&!(e in r)){const c=Object.getOwnPropertyDescriptor(t,e);c&&Object.defineProperty(r,e,c.get?c:{enumerable:!0,get:()=>t[e]})}}}return Object.freeze(Object.defineProperty(r,Symbol.toStringTag,{value:"Module"}))}var n=s();const f=a(n),l=p({__proto__:null,default:f},[n]);export{l as a};

package/web-ui/build/static/ada-CCVAXM0c.js

@@ -0,0 +1 @@
+import{g as s,f as c}from"./index-Be9WvMkI.js";function i(t,n){for(var o=0;o<n.length;o++){const e=n[o];if(typeof e!="string"&&!Array.isArray(e)){for(const r in e)if(r!=="default"&&!(r in t)){const a=Object.getOwnPropertyDescriptor(e,r);a&&Object.defineProperty(t,r,a.get?a:{enumerable:!0,get:()=>e[r]})}}}return Object.freeze(Object.defineProperty(t,Symbol.toStringTag,{value:"Module"}))}var f=c();const p=s(f),d=i({__proto__:null,default:p},[f]);export{d as a};

package/web-ui/build/static/ada-DtGkgqC4.js

@@ -0,0 +1 @@
+import{g as s}from"./index-Be9WvMkI.js";import{d as i}from"./index-CuZ_erP9.js";function c(t,n){for(var o=0;o<n.length;o++){const e=n[o];if(typeof e!="string"&&!Array.isArray(e)){for(const r in e)if(r!=="default"&&!(r in t)){const a=Object.getOwnPropertyDescriptor(e,r);a&&Object.defineProperty(t,r,a.get?a:{enumerable:!0,get:()=>e[r]})}}}return Object.freeze(Object.defineProperty(t,Symbol.toStringTag,{value:"Module"}))}var f=i();const p=s(f),g=c({__proto__:null,default:p},[f]);export{g as a};

package/web-ui/build/static/agda-gMFRTChb.js

@@ -0,0 +1 @@
+import{g as f,h as g}from"./index-Be9WvMkI.js";function c(t,n){for(var o=0;o<n.length;o++){const e=n[o];if(typeof e!="string"&&!Array.isArray(e)){for(const r in e)if(r!=="default"&&!(r in t)){const a=Object.getOwnPropertyDescriptor(e,r);a&&Object.defineProperty(t,r,a.get?a:{enumerable:!0,get:()=>e[r]})}}}return Object.freeze(Object.defineProperty(t,Symbol.toStringTag,{value:"Module"}))}var s=g();const i=f(s),u=c({__proto__:null,default:i},[s]);export{u as a};

package/web-ui/build/static/al-88fYQh4r.js

@@ -0,0 +1 @@
+import{g as f,k as l}from"./index-Be9WvMkI.js";function c(t,n){for(var o=0;o<n.length;o++){const e=n[o];if(typeof e!="string"&&!Array.isArray(e)){for(const r in e)if(r!=="default"&&!(r in t)){const a=Object.getOwnPropertyDescriptor(e,r);a&&Object.defineProperty(t,r,a.get?a:{enumerable:!0,get:()=>e[r]})}}}return Object.freeze(Object.defineProperty(t,Symbol.toStringTag,{value:"Module"}))}var s=l();const i=f(s),u=c({__proto__:null,default:i},[s]);export{u as a};

package/web-ui/build/static/angelscript-Bibc8YWJ.js

@@ -0,0 +1 @@
+import{g as i}from"./index-Be9WvMkI.js";import{e as c}from"./index-CuZ_erP9.js";function p(t,a){for(var o=0;o<a.length;o++){const e=a[o];if(typeof e!="string"&&!Array.isArray(e)){for(const r in e)if(r!=="default"&&!(r in t)){const n=Object.getOwnPropertyDescriptor(e,r);n&&Object.defineProperty(t,r,n.get?n:{enumerable:!0,get:()=>e[r]})}}}return Object.freeze(Object.defineProperty(t,Symbol.toStringTag,{value:"Module"}))}var s=c();const f=i(s),u=p({__proto__:null,default:f},[s]);export{u as a};

package/web-ui/build/static/antlr4-DgibPJaJ.js

@@ -0,0 +1 @@
+import{g as s,l as f}from"./index-Be9WvMkI.js";function c(t,a){for(var o=0;o<a.length;o++){const e=a[o];if(typeof e!="string"&&!Array.isArray(e)){for(const r in e)if(r!=="default"&&!(r in t)){const n=Object.getOwnPropertyDescriptor(e,r);n&&Object.defineProperty(t,r,n.get?n:{enumerable:!0,get:()=>e[r]})}}}return Object.freeze(Object.defineProperty(t,Symbol.toStringTag,{value:"Module"}))}var l=f();const i=s(l),u=c({__proto__:null,default:i},[l]);export{u as a};