onbuzz 4.9.5 → 4.9.8

package/src/interfaces/__tests__/keyProbe.test.js

@@ -0,0 +1,187 @@
+/**
+ * keyProbe.test.js — locks the behaviour of WebServer._probeLoxiaKey
+ * (the upstream Loxia-API-key validator that powers the new `keyValid`
+ * field on /api/keys/:sessionId).
+ *
+ * Why this is critical: prior to this change, the front-end's auto-
+ * restore path treated `hasLoxiaKey: true` as "the platform key works,
+ * skip pushing the user's localStorage key". A stale/revoked key on
+ * disk made that branch silently fire every session — every agent
+ * message then 401'd in the streaming layer with no recovery. The
+ * probe is the single source of truth that lets the front-end decide
+ * whether to trust the server's stored key.
+ *
+ * We mock global.fetch rather than spin up an HTTP harness because
+ * the probe's contract IS the fetch behaviour we want to lock in.
+ */
+import { describe, it, expect, beforeEach, afterEach, jest } from '@jest/globals';
+
+const SILENT_LOGGER = { info() {}, warn() {}, error() {}, debug() {} };
+
+/**
+ * Build a minimal WebServer instance with just the bits _probeLoxiaKey
+ * needs. We can't easily import the full WebServer class without
+ * dragging in 60+ other deps, so we extract the method via the same
+ * code path with a small shim that mirrors the structure.
+ *
+ * This shim MUST be kept in sync with WebServer._probeLoxiaKey in
+ * src/interfaces/webServer.js — when the production method changes,
+ * update this shim in the same commit.
+ */
+function makeProber({ baseUrl = 'https://upstream.test/api', logger = SILENT_LOGGER } = {}) {
+  const self = {
+    config: { backend: { baseUrl } },
+    logger,
+    _keyProbeCache: new Map(),
+  };
+
+  self._probeLoxiaKey = async function (apiKey) {
+    if (!apiKey || typeof apiKey !== 'string') {
+      return { ok: false, reason: 'no-key' };
+    }
+    const KEY_PROBE_TTL_MS = 60_000;
+    const fp = apiKey.slice(0, 12);
+    const now = Date.now();
+    const cached = this._keyProbeCache.get(fp);
+    if (cached && (now - cached.at) < KEY_PROBE_TTL_MS) return cached.result;
+
+    const baseUrl = this.config.backend?.baseUrl;
+    let result;
+    try {
+      const controller = new AbortController();
+      const timeout = setTimeout(() => controller.abort(), 5000);
+      const response = await fetch(`${baseUrl}/llm/models`, {
+        method: 'GET',
+        headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${apiKey}` },
+        signal: controller.signal,
+      });
+      clearTimeout(timeout);
+      if (response.ok) result = { ok: true, reason: 'ok' };
+      else if (response.status === 401 || response.status === 403) result = { ok: false, reason: 'unauthorised' };
+      else result = { ok: false, reason: 'probe-failed' };
+    } catch {
+      result = { ok: false, reason: 'probe-failed' };
+    }
+
+    this._keyProbeCache.set(fp, { at: now, result });
+    return result;
+  };
+
+  return self;
+}
+
+let originalFetch;
+beforeEach(() => {
+  originalFetch = global.fetch;
+});
+afterEach(() => {
+  global.fetch = originalFetch;
+});
+
+describe('_probeLoxiaKey — input validation', () => {
+  it('reports `no-key` immediately when the key is falsy or non-string', async () => {
+    const p = makeProber();
+    expect(await p._probeLoxiaKey(null)).toEqual({ ok: false, reason: 'no-key' });
+    expect(await p._probeLoxiaKey(undefined)).toEqual({ ok: false, reason: 'no-key' });
+    expect(await p._probeLoxiaKey('')).toEqual({ ok: false, reason: 'no-key' });
+    expect(await p._probeLoxiaKey({})).toEqual({ ok: false, reason: 'no-key' });
+  });
+
+  it('does not call fetch for a falsy key — no upstream traffic', async () => {
+    const p = makeProber();
+    global.fetch = jest.fn();
+    await p._probeLoxiaKey('');
+    expect(global.fetch).not.toHaveBeenCalled();
+  });
+});
+
+describe('_probeLoxiaKey — upstream classification', () => {
+  it('200 from upstream → { ok: true, reason: "ok" }', async () => {
+    global.fetch = jest.fn().mockResolvedValue(new Response('{}', { status: 200 }));
+    const p = makeProber();
+    expect(await p._probeLoxiaKey('lx_valid_key_123')).toEqual({ ok: true, reason: 'ok' });
+    // Verifies the probe hit the right endpoint with bearer auth.
+    expect(global.fetch).toHaveBeenCalledWith(
+      'https://upstream.test/api/llm/models',
+      expect.objectContaining({
+        method: 'GET',
+        headers: expect.objectContaining({ Authorization: 'Bearer lx_valid_key_123' }),
+      }),
+    );
+  });
+
+  it('401 from upstream → { ok: false, reason: "unauthorised" }', async () => {
+    global.fetch = jest.fn().mockResolvedValue(new Response('{"error":"Invalid API key"}', { status: 401 }));
+    const p = makeProber();
+    expect(await p._probeLoxiaKey('lx_revoked_key')).toEqual({ ok: false, reason: 'unauthorised' });
+  });
+
+  it('403 from upstream → also classified as unauthorised', async () => {
+    global.fetch = jest.fn().mockResolvedValue(new Response('Forbidden', { status: 403 }));
+    const p = makeProber();
+    expect(await p._probeLoxiaKey('lx_forbidden_key')).toEqual({ ok: false, reason: 'unauthorised' });
+  });
+
+  it('500 from upstream → { ok: false, reason: "probe-failed" } — inconclusive, NOT a key problem', async () => {
+    // The distinction matters: a real auth failure should make the
+    // front-end push the user's localStorage key. An upstream 5xx
+    // should NOT, because the stored key might be perfectly fine.
+    global.fetch = jest.fn().mockResolvedValue(new Response('boom', { status: 500 }));
+    const p = makeProber();
+    const r = await p._probeLoxiaKey('lx_key_during_outage');
+    expect(r.ok).toBe(false);
+    expect(r.reason).toBe('probe-failed');
+  });
+
+  it('network/timeout error → { ok: false, reason: "probe-failed" }', async () => {
+    global.fetch = jest.fn().mockRejectedValue(new Error('ECONNREFUSED'));
+    const p = makeProber();
+    expect(await p._probeLoxiaKey('lx_offline_key')).toEqual({ ok: false, reason: 'probe-failed' });
+  });
+});
+
+describe('_probeLoxiaKey — caching', () => {
+  it('second probe of the same key within 60s returns the cached result without hitting fetch', async () => {
+    global.fetch = jest.fn().mockResolvedValue(new Response('{}', { status: 200 }));
+    const p = makeProber();
+    const r1 = await p._probeLoxiaKey('lx_cacheable_key_abc');
+    const r2 = await p._probeLoxiaKey('lx_cacheable_key_abc');
+    expect(r1).toEqual({ ok: true, reason: 'ok' });
+    expect(r2).toEqual({ ok: true, reason: 'ok' });
+    expect(global.fetch).toHaveBeenCalledTimes(1);
+  });
+
+  it('cache key is the FINGERPRINT (first 12 chars) — collisions yield same result', async () => {
+    // Two keys sharing the first 12 chars are treated as the same
+    // logical key by the cache. This is a deliberate trade-off: we
+    // never want the full key in any in-memory cache structure that
+    // gets logged or debugged.
+    global.fetch = jest.fn().mockResolvedValue(new Response('{}', { status: 200 }));
+    const p = makeProber();
+    await p._probeLoxiaKey('lx_sharedstart_AAAAAA');
+    await p._probeLoxiaKey('lx_sharedstart_BBBBBB');
+    expect(global.fetch).toHaveBeenCalledTimes(1);
+  });
+
+  it('different fingerprints probe separately', async () => {
+    global.fetch = jest.fn()
+      .mockResolvedValueOnce(new Response('{}', { status: 200 }))
+      .mockResolvedValueOnce(new Response('nope', { status: 401 }));
+    const p = makeProber();
+    expect(await p._probeLoxiaKey('lx_aaaaaaaaaaaa')).toEqual({ ok: true, reason: 'ok' });
+    expect(await p._probeLoxiaKey('lx_zzzzzzzzzzzz')).toEqual({ ok: false, reason: 'unauthorised' });
+    expect(global.fetch).toHaveBeenCalledTimes(2);
+  });
+
+  it('caches negative results too — prevents hammering the backend with a known-bad key', async () => {
+    // Without this, every visit to Settings would issue an upstream
+    // 401 — gives the user a worse experience and gives the upstream
+    // a worse signal/noise ratio on their auth metrics.
+    global.fetch = jest.fn().mockResolvedValue(new Response('bad', { status: 401 }));
+    const p = makeProber();
+    await p._probeLoxiaKey('lx_stale_key_abcd');
+    await p._probeLoxiaKey('lx_stale_key_abcd');
+    await p._probeLoxiaKey('lx_stale_key_abcd');
+    expect(global.fetch).toHaveBeenCalledTimes(1);
+  });
+});

package/src/interfaces/webServer.js

@@ -2061,31 +2061,49 @@ h2{color:#16a34a;margin-bottom:.5rem;} p{color:#666;}</style></head>
     this.app.get('/api/keys/:sessionId', async (req, res) => {
       try {
         const { sessionId } = req.params;
-        
+
         if (!this.apiKeyManager) {
           return res.status(500).json({
             success: false,
             error: 'API key manager not available'
           });
         }
-        
+
         const keys = this.apiKeyManager.getSessionKeys(sessionId);
-        
-        // Return key presence only, not actual values
+        const hasLoxiaKey = !!keys.loxiaApiKey;
+
+        // Validate the stored key against the upstream backend so
+        // `hasLoxiaKey: true` actually means "this key works", not just
+        // "a key string exists in apiKeyManager". Without this, a stale/
+        // revoked key on disk silently 401s every agent message while
+        // the front-end happily reports "platform-managed key, all good"
+        // and skips pushing the user's correct localStorage key.
+        let keyValid = null;       // null = not probed (no key to probe)
+        let keyValidReason = null; // 'ok' | 'no-key' | 'unauthorised' | 'probe-failed'
+        if (hasLoxiaKey) {
+          const probe = await this._probeLoxiaKey(keys.loxiaApiKey);
+          keyValid = probe.ok;
+          keyValidReason = probe.reason;
+        } else {
+          keyValidReason = 'no-key';
+        }
+
         res.json({
           success: true,
           sessionId,
-          hasLoxiaKey: !!keys.loxiaApiKey,
+          hasLoxiaKey,
+          keyValid,
+          keyValidReason,
           vendorKeys: Object.keys(keys.vendorKeys || {}),
           updatedAt: keys.updatedAt
         });
-        
+
       } catch (error) {
         this.logger.error('Failed to get API key status', {
           error: error.message,
           sessionId: req.params.sessionId
         });
-        
+
         res.status(500).json({
           success: false,
           error: error.message
@@ -7330,6 +7348,69 @@ h2{color:#16a34a;margin-bottom:.5rem;} p{color:#666;}</style></head>
     };
   }
 
+  /**
+   * Probe a Loxia API key against the upstream backend so we can
+   * report `keyValid: true | false` from /api/keys/:sessionId. Without
+   * this, the front-end's "trust the server-side key" branch fires
+   * even when the stored key is stale/revoked → every agent message
+   * 401s silently. Cached per-fingerprint for `KEY_PROBE_TTL_MS` so
+   * we don't hammer the backend on every key-status poll.
+   *
+   * @param {string} apiKey
+   * @returns {Promise<{ok: boolean, reason: 'ok'|'unauthorised'|'probe-failed'}>}
+   */
+  async _probeLoxiaKey(apiKey) {
+    if (!apiKey || typeof apiKey !== 'string') {
+      return { ok: false, reason: 'no-key' };
+    }
+    if (!this._keyProbeCache) this._keyProbeCache = new Map();
+    const KEY_PROBE_TTL_MS = 60_000;
+    const fp = apiKey.slice(0, 12);   // fingerprint, not the whole key
+    const now = Date.now();
+    const cached = this._keyProbeCache.get(fp);
+    if (cached && (now - cached.at) < KEY_PROBE_TTL_MS) {
+      return cached.result;
+    }
+
+    const baseUrl = this.config.backend?.baseUrl || 'https://loxia-api-g7hrb8bxdae8a2h7.z02.azurefd.net';
+    const probeUrl = `${baseUrl}/llm/models`;
+    let result;
+    try {
+      const controller = new AbortController();
+      const timeout = setTimeout(() => controller.abort(), 5000);
+      const response = await fetch(probeUrl, {
+        method: 'GET',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${apiKey}`,
+        },
+        signal: controller.signal,
+      });
+      clearTimeout(timeout);
+      if (response.ok) {
+        result = { ok: true, reason: 'ok' };
+      } else if (response.status === 401 || response.status === 403) {
+        result = { ok: false, reason: 'unauthorised' };
+      } else {
+        // 5xx, 4xx that isn't auth — treat as inconclusive (cache briefly
+        // so we don't probe on every poll, but don't lock in `false`).
+        result = { ok: false, reason: 'probe-failed' };
+      }
+    } catch (e) {
+      // Network error, timeout, etc. — inconclusive, not a key problem.
+      this.logger.debug?.('Loxia key probe failed', { error: e.message });
+      result = { ok: false, reason: 'probe-failed' };
+    }
+
+    this._keyProbeCache.set(fp, { at: now, result });
+    return result;
+  }
+
+  /** Test hook — wipe the probe cache so tests don't pollute each other. */
+  _resetKeyProbeCacheForTests() {
+    this._keyProbeCache = new Map();
+  }
+
   /**
    * Shutdown the web server
    * @returns {Promise<void>}

package/src/tools/__tests__/officeTool.test.js

@@ -330,6 +330,97 @@ describe('officeTool — pres.* fidelity', () => {
     expect(info.success).toBe(true);
     expect(info.info.slideCount).toBe(3);
   });
+
+  // ─── Themed presentation system (string theme routes to the new builder) ──
+
+  test('pres.system lists themes, archetypes, backgrounds — no file needed', async () => {
+    const t = makeTool();
+    const r = await t.execute({ actions: [{ type: 'pres.system' }] }, context);
+    expect(r.success).toBe(true);
+    expect(r.themes.map(x => x.id)).toEqual(expect.arrayContaining(['editorial-warm', 'tech-bold', 'data-heavy']));
+    expect(r.archetypes).toEqual(expect.arrayContaining(['hero', 'agenda', 'statCallout', 'twoColChart', 'closing']));
+    expect(r.backgrounds).toEqual(expect.arrayContaining(['solid', 'gradient', 'mesh', 'noise', 'geometric', 'grid']));
+  });
+
+  test('pres.create with string theme + archetype slides routes through the themed builder', async () => {
+    const t = makeTool();
+    const target = outPath();
+    const r = await t.execute({
+      actions: [{
+        type: 'pres.create',
+        outputPath: target,
+        content: {
+          title: 'Themed Deck',
+          theme: 'editorial-warm',
+          slides: [
+            { archetype: 'hero', eyebrow: 'Q4', title: 'Hello', subtitle: 'World', author: 'Bench', date: '2026' },
+            { archetype: 'statCallout', stat: '47%', label: 'YoY growth', footnote: 'Source: bench' },
+            { archetype: 'bullets', title: 'Wins', items: ['A', 'B', 'C'] },
+            { archetype: 'closing', title: 'Thanks' },
+          ],
+        },
+      }],
+    }, context);
+    expect(r.success).toBe(true);
+    expect(r.slideCount).toBe(4);
+    expect(r.theme).toBe('editorial-warm');
+    expect(r.palette).toBe('cream-charcoal');
+    expect(r.fileSize).toBeGreaterThan(10_000);
+  }, 15000);
+
+  test('pres.read returns slide outline + tokens for an existing .pptx', async () => {
+    const t = makeTool();
+    const target = outPath();
+    // Build a template deck with {{tokens}}.
+    await t.execute({
+      actions: [{
+        type: 'pres.create',
+        outputPath: target,
+        content: {
+          title: 'Template',
+          theme: 'tech-bold',
+          slides: [
+            { archetype: 'hero', title: 'Hello {{customerName}}', subtitle: 'On {{date}}' },
+            { archetype: 'statCallout', stat: '{{metric}}', label: 'For {{customerName}}' },
+          ],
+        },
+      }],
+    }, context);
+
+    const r = await t.execute({ actions: [{ type: 'pres.read', filePath: target }] }, context);
+    expect(r.success).toBe(true);
+    expect(r.slideCount).toBe(2);
+    expect(r.tokens).toEqual(expect.arrayContaining(['customerName', 'date', 'metric']));
+  }, 15000);
+
+  test('pres.fill replaces {{tokens}} with provided values', async () => {
+    const t = makeTool();
+    const templatePath = outPath();
+    const filledPath = outPath();
+    await t.execute({
+      actions: [{
+        type: 'pres.create',
+        outputPath: templatePath,
+        content: {
+          theme: 'editorial-warm',
+          slides: [
+            { archetype: 'hero', title: 'Hi {{name}}', subtitle: '{{date}}' },
+          ],
+        },
+      }],
+    }, context);
+    const r = await t.execute({
+      actions: [{
+        type: 'pres.fill',
+        sourcePath: templatePath,
+        outputPath: filledPath,
+        values: { name: 'Acme', date: 'May 28' },
+      }],
+    }, context);
+    expect(r.success).toBe(true);
+    expect(r.replaced).toEqual({ name: 1, date: 1 });
+    expect(r.unresolved).toEqual([]);
+  }, 15000);
 });
 
 /* ------------------------------------------------------------------------ */

package/src/tools/office/officePres.js

@@ -23,6 +23,14 @@ import fs from 'fs/promises';
 import path from 'path';
 import { createRequire } from 'module';
 
+// Themed-presentation system. Opt-in via `theme: '<preset-name>'` on
+// the spec — when present we route to the new builder for stunning
+// curated decks; otherwise we keep the legacy pptxgenjs-direct path
+// below for backwards compatibility.
+import { isThemedSpec, buildThemedPres, listSystem } from './pres/index.js';
+import { readPres } from './pres/edit/read.js';
+import { fillPres } from './pres/edit/fill.js';
+
 // pptxgenjs ships dual builds (ESM + CJS). The ESM build does
 // `import JSZip from 'jszip'` which jszip (CJS-only) does not satisfy
 // cleanly under jest's experimental-vm-modules. Loading via createRequire
@@ -216,6 +224,13 @@ function placeItem(slide, item, defaults) {
 /* ------------------------------------------------------------------------ */
 
 export async function createPres(spec, outputPath) {
+  // New themed path: any spec with a string `theme` (one of the
+  // registered presets) routes to the curated archetype system, which
+  // produces decks the agent doesn't have to hand-design.
+  if (isThemedSpec(spec)) {
+    return await buildThemedPres(spec, outputPath);
+  }
+
   const Pptx = loadPptx();
   const pptx = new Pptx();
 
@@ -333,6 +348,35 @@ export async function createPres(spec, outputPath) {
   return { path: outputPath, size: stat.size, slideCount: slides.length };
 }
 
+/* ----- read / fill: outline + token replacement for existing decks ----- */
+
+/**
+ * Read the structural outline + tokens of an existing .pptx so the
+ * agent can decide what to fill. Delegates to pres/edit/read.js so the
+ * heavy XML walk lives in its own file.
+ */
+export async function readPresOutline(filePath) {
+  return await readPres(filePath);
+}
+
+/**
+ * Fill `{{token}}` placeholders in an existing .pptx with the provided
+ * `values` map. Delegates to pres/edit/fill.js. Lets the agent take a
+ * hand-made template deck and stamp customer/data specifics into it
+ * without ever touching the design.
+ */
+export async function fillPresPlaceholders(args) {
+  return await fillPres(args);
+}
+
+/**
+ * Expose the available themes / archetypes / backgrounds for the
+ * agent-facing tool docstring + the showcase verifier.
+ */
+export function listPresentationSystem() {
+  return listSystem();
+}
+
 /* ----- info (light reader via JSZip) ----- */
 
 export async function presInfo(filePath) {