onbuzz 3.8.13 → 3.9.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "onbuzz",
-  "version": "3.8.13",
+  "version": "3.9.1",
   "description": "Loxia OnBuzz - Your AI Fleet",
   "type": "module",
   "main": "src/index.js",

package/src/__tests__/marketplaceApi.test.js

@@ -0,0 +1,242 @@
+/**
+ * Tests for the marketplaceApi client (web-ui/src/services/marketplaceApi.js).
+ *
+ * Lives under src/__tests__ (the unit project) instead of web-ui/ because the
+ * service uses ESM + import.meta.env, which the esbuild-jest transform in the
+ * react project can't process under --experimental-vm-modules. Running it
+ * under the unit project (node env, native ESM) avoids that issue entirely.
+ *
+ * We provide a minimal localStorage stub since node env doesn't have one.
+ */
+
+import { jest, describe, test, expect, beforeEach, afterEach, beforeAll } from '@jest/globals';
+
+// ── localStorage stub ─────────────────────────────────────────────
+class LocalStorageStub {
+  constructor() { this._store = new Map(); }
+  getItem(key) { return this._store.has(key) ? this._store.get(key) : null; }
+  setItem(key, value) { this._store.set(key, String(value)); }
+  removeItem(key) { this._store.delete(key); }
+  clear() { this._store.clear(); }
+}
+global.localStorage = new LocalStorageStub();
+
+let marketplaceApi;
+
+beforeAll(async () => {
+  ({ marketplaceApi } = await import('../../web-ui/src/services/marketplaceApi.js'));
+});
+
+const BASE = 'https://autopilot-marketplace.azurewebsites.net';
+
+function mockFetchResponse(body, ok = true, status = 200) {
+  return Promise.resolve({
+    ok,
+    status,
+    json: () => Promise.resolve(body)
+  });
+}
+
+describe('marketplaceApi', () => {
+  beforeEach(() => {
+    global.fetch = jest.fn();
+    global.localStorage.clear();
+  });
+
+  afterEach(() => {
+    delete global.fetch;
+  });
+
+  describe('_getHeaders / auth', () => {
+    test('omits Authorization header when no token in localStorage', async () => {
+      global.fetch.mockReturnValue(mockFetchResponse({ success: true, items: [] }));
+      await marketplaceApi.searchItems();
+      const headers = global.fetch.mock.calls[0][1].headers;
+      expect(headers['Authorization']).toBeUndefined();
+      expect(headers['Content-Type']).toBe('application/json');
+    });
+
+    test('includes Bearer token when present in localStorage', async () => {
+      global.localStorage.setItem('loxia-auth-token', 'jwt-abc-123');
+      global.fetch.mockReturnValue(mockFetchResponse({ success: true, items: [] }));
+      await marketplaceApi.searchItems();
+      const headers = global.fetch.mock.calls[0][1].headers;
+      expect(headers['Authorization']).toBe('Bearer jwt-abc-123');
+    });
+  });
+
+  describe('searchItems', () => {
+    test('builds query string with all params', async () => {
+      global.fetch.mockReturnValue(mockFetchResponse({ success: true, items: [] }));
+      await marketplaceApi.searchItems({ query: 'test', type: 'skill', sort: 'rating', page: 2, limit: 10 });
+
+      const url = global.fetch.mock.calls[0][0];
+      expect(url).toContain('q=test');
+      expect(url).toContain('type=skill');
+      expect(url).toContain('sort=rating');
+      expect(url).toContain('page=2');
+      expect(url).toContain('limit=10');
+      expect(url).toMatch(new RegExp(`^${BASE}/api/items\\?`));
+    });
+
+    test('uses sensible defaults when called with no args', async () => {
+      global.fetch.mockReturnValue(mockFetchResponse({ success: true, items: [] }));
+      await marketplaceApi.searchItems();
+      const url = global.fetch.mock.calls[0][0];
+      expect(url).toContain('sort=downloads');
+      expect(url).toContain('page=1');
+      expect(url).toContain('limit=20');
+      expect(url).not.toMatch(/[?&]q=/);
+      expect(url).not.toMatch(/[?&]type=/);
+    });
+
+    test('omits empty query and type from URL', async () => {
+      global.fetch.mockReturnValue(mockFetchResponse({ success: true, items: [] }));
+      await marketplaceApi.searchItems({ query: '', type: '' });
+      const url = global.fetch.mock.calls[0][0];
+      expect(url).not.toMatch(/[?&]q=/);
+      expect(url).not.toMatch(/[?&]type=/);
+    });
+  });
+
+  describe('getItem', () => {
+    test('fetches /api/items/:id', async () => {
+      global.fetch.mockReturnValue(mockFetchResponse({ success: true, item: { id: 'abc' } }));
+      const result = await marketplaceApi.getItem('abc-123');
+      expect(global.fetch.mock.calls[0][0]).toBe(`${BASE}/api/items/abc-123`);
+      expect(result.item.id).toBe('abc');
+    });
+  });
+
+  describe('downloadItem', () => {
+    test('fetches /api/items/:id/download with redirect follow', async () => {
+      global.fetch.mockReturnValue(mockFetchResponse({ name: 'My Skill', sections: [] }));
+      const data = await marketplaceApi.downloadItem('id-1');
+      expect(global.fetch.mock.calls[0][0]).toBe(`${BASE}/api/items/id-1/download`);
+      expect(global.fetch.mock.calls[0][1].redirect).toBe('follow');
+      expect(data.name).toBe('My Skill');
+    });
+
+    test('throws on non-OK download', async () => {
+      global.fetch.mockReturnValue(mockFetchResponse({}, false, 404));
+      await expect(marketplaceApi.downloadItem('missing')).rejects.toThrow('Download failed: 404');
+    });
+  });
+
+  describe('getFeatured', () => {
+    test('fetches /api/items/featured', async () => {
+      global.fetch.mockReturnValue(mockFetchResponse({ success: true, items: [] }));
+      await marketplaceApi.getFeatured();
+      expect(global.fetch.mock.calls[0][0]).toBe(`${BASE}/api/items/featured`);
+    });
+  });
+
+  describe('publishItem', () => {
+    test('POSTs to /api/items with full body', async () => {
+      global.localStorage.setItem('loxia-auth-token', 'jwt');
+      global.fetch.mockReturnValue(mockFetchResponse({ success: true, item: { id: 'new' } }));
+
+      await marketplaceApi.publishItem({
+        type: 'skill',
+        name: 'My Skill',
+        description: 'A test skill',
+        tags: ['ai', 'utility'],
+        content: { sections: [] },
+        metadata: { difficulty: 'easy' },
+        authorName: 'Test User'
+      });
+
+      const call = global.fetch.mock.calls[0];
+      expect(call[0]).toBe(`${BASE}/api/items`);
+      expect(call[1].method).toBe('POST');
+      expect(call[1].headers['Authorization']).toBe('Bearer jwt');
+
+      const body = JSON.parse(call[1].body);
+      expect(body.type).toBe('skill');
+      expect(body.name).toBe('My Skill');
+      expect(body.tags).toEqual(['ai', 'utility']);
+      expect(body.metadata.difficulty).toBe('easy');
+      expect(body.authorName).toBe('Test User');
+    });
+
+    test('throws with server error message on failed publish', async () => {
+      global.fetch.mockReturnValue(mockFetchResponse({ error: 'name is required' }, false, 400));
+      await expect(marketplaceApi.publishItem({ type: 'skill' }))
+        .rejects.toThrow('name is required');
+    });
+
+    test('falls back to HTTP status when response has no error field', async () => {
+      global.fetch.mockReturnValue(mockFetchResponse({}, false, 500));
+      await expect(marketplaceApi.publishItem({})).rejects.toThrow('HTTP 500');
+    });
+  });
+
+  describe('updateItem', () => {
+    test('PUTs to /api/items/:id with body', async () => {
+      global.fetch.mockReturnValue(mockFetchResponse({ success: true, item: {} }));
+      await marketplaceApi.updateItem('item-1', { name: 'New name' });
+      const call = global.fetch.mock.calls[0];
+      expect(call[0]).toBe(`${BASE}/api/items/item-1`);
+      expect(call[1].method).toBe('PUT');
+      expect(JSON.parse(call[1].body).name).toBe('New name');
+    });
+  });
+
+  describe('deleteItem', () => {
+    test('DELETEs /api/items/:id', async () => {
+      global.fetch.mockReturnValue(mockFetchResponse({ success: true }));
+      await marketplaceApi.deleteItem('item-1');
+      const call = global.fetch.mock.calls[0];
+      expect(call[0]).toBe(`${BASE}/api/items/item-1`);
+      expect(call[1].method).toBe('DELETE');
+    });
+  });
+
+  describe('rateItem', () => {
+    test('POSTs to /api/items/:id/rate with rating body', async () => {
+      global.fetch.mockReturnValue(mockFetchResponse({ success: true, rating_avg: 4.5, rating_count: 2 }));
+      await marketplaceApi.rateItem('item-1', { rating: 5, review: 'Great!', userName: 'Bob' });
+
+      const call = global.fetch.mock.calls[0];
+      expect(call[0]).toBe(`${BASE}/api/items/item-1/rate`);
+      expect(call[1].method).toBe('POST');
+      const body = JSON.parse(call[1].body);
+      expect(body.rating).toBe(5);
+      expect(body.review).toBe('Great!');
+      expect(body.userName).toBe('Bob');
+    });
+  });
+
+  describe('getMyItems', () => {
+    test('fetches /api/my-items', async () => {
+      global.fetch.mockReturnValue(mockFetchResponse({ success: true, items: [] }));
+      await marketplaceApi.getMyItems();
+      expect(global.fetch.mock.calls[0][0]).toBe(`${BASE}/api/my-items`);
+    });
+  });
+
+  describe('isAvailable', () => {
+    test('returns true when health endpoint reports OK', async () => {
+      global.fetch.mockReturnValue(Promise.resolve({
+        ok: true,
+        json: () => Promise.resolve({ status: 'OK' })
+      }));
+      const available = await marketplaceApi.isAvailable();
+      expect(available).toBe(true);
+      expect(global.fetch.mock.calls[0][0]).toBe(`${BASE}/health`);
+    });
+
+    test('returns false when health endpoint reports non-OK status', async () => {
+      global.fetch.mockReturnValue(Promise.resolve({
+        ok: true,
+        json: () => Promise.resolve({ status: 'DEGRADED' })
+      }));
+      expect(await marketplaceApi.isAvailable()).toBe(false);
+    });
+
+    test('returns false when fetch throws (network error)', async () => {
+      global.fetch.mockImplementation(() => { throw new Error('Network error'); });
+      expect(await marketplaceApi.isAvailable()).toBe(false);
+    });
+  });
+});

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

@@ -0,0 +1,207 @@
+/**
+ * Tests for DELETE /api/agents/archived/:agentId
+ *
+ * Verifies:
+ *   - Active (loaded) agents cannot be deleted via this endpoint
+ *   - State, conversations, and memory files are removed from disk
+ *   - Missing files (ENOENT) are silently skipped (not all agents have all 3)
+ *   - Agent index entry is removed
+ *   - Other unexpected errors propagate as 500
+ *
+ * Uses minimal Express harness pattern (replicates the route handler from
+ * webServer.js bound to a fake `this` context).
+ */
+import { describe, it, expect, beforeEach, afterEach, jest } from '@jest/globals';
+import express from 'express';
+import { createServer } from 'http';
+import { promises as fs } from 'fs';
+import path from 'path';
+import os from 'os';
+
+function buildApp({ orchestrator, logger }) {
+  const app = express();
+  app.use(express.json());
+
+  app.delete('/api/agents/archived/:agentId', async (req, res) => {
+    try {
+      const { agentId } = req.params;
+      if (!agentId) {
+        return res.status(400).json({ success: false, error: 'agentId is required' });
+      }
+
+      const activeAgent = await orchestrator.agentPool.getAgent(agentId);
+      if (activeAgent) {
+        return res.status(400).json({ success: false, error: 'Cannot delete an active agent. Unload it first.' });
+      }
+
+      const agentsDir = orchestrator.stateManager.getAgentsDir();
+      const deletedFiles = [];
+
+      for (const suffix of ['-state.json', '-conversations.json', '-memory.json']) {
+        const filePath = path.join(agentsDir, `${agentId}${suffix}`);
+        try {
+          await fs.unlink(filePath);
+          deletedFiles.push(filePath);
+        } catch (err) {
+          if (err.code !== 'ENOENT') throw err;
+        }
+      }
+
+      const projectDir = orchestrator.config.project?.directory || process.cwd();
+      try {
+        const agentIndex = await orchestrator.stateManager.loadAgentIndex(projectDir);
+        if (agentIndex[agentId]) {
+          delete agentIndex[agentId];
+          await orchestrator.stateManager.updateAgentIndex(projectDir, agentIndex);
+        }
+      } catch {}
+
+      logger?.info?.('Archived agent deleted from disk', { agentId, deletedFiles });
+      res.json({ success: true, agentId, deletedFiles });
+    } catch (error) {
+      logger?.error?.('Failed to delete archived agent', { error: error.message });
+      res.status(500).json({ success: false, error: error.message });
+    }
+  });
+
+  return app;
+}
+
+async function startServer(app) {
+  const server = createServer(app);
+  await new Promise(resolve => server.listen(0, resolve));
+  return { server, baseUrl: `http://127.0.0.1:${server.address().port}` };
+}
+
+describe('DELETE /api/agents/archived/:agentId', () => {
+  let tmpAgentsDir;
+  let server;
+  let logger;
+
+  beforeEach(async () => {
+    tmpAgentsDir = await fs.mkdtemp(path.join(os.tmpdir(), 'archived-agents-'));
+    logger = { info: jest.fn(), error: jest.fn(), warn: jest.fn() };
+    server = null;
+  });
+
+  afterEach(async () => {
+    if (server) server.close();
+    await fs.rm(tmpAgentsDir, { recursive: true, force: true }).catch(() => {});
+  });
+
+  function makeOrchestrator({ getAgentResult = null, agentIndex = {}, indexThrows = false } = {}) {
+    let storedIndex = { ...agentIndex };
+    return {
+      agentPool: {
+        getAgent: jest.fn(async () => getAgentResult)
+      },
+      stateManager: {
+        getAgentsDir: () => tmpAgentsDir,
+        loadAgentIndex: jest.fn(async () => {
+          if (indexThrows) throw new Error('index load failed');
+          return storedIndex;
+        }),
+        updateAgentIndex: jest.fn(async (_dir, idx) => { storedIndex = idx; }),
+        _getStoredIndex: () => storedIndex
+      },
+      config: { project: { directory: tmpAgentsDir } }
+    };
+  }
+
+  it('refuses to delete when agent is currently loaded (active)', async () => {
+    const orchestrator = makeOrchestrator({ getAgentResult: { id: 'agent-1', isLoaded: true } });
+    const { server: s, baseUrl } = await startServer(buildApp({ orchestrator, logger }));
+    server = s;
+
+    const res = await fetch(`${baseUrl}/api/agents/archived/agent-1`, { method: 'DELETE' });
+    expect(res.status).toBe(400);
+    const body = await res.json();
+    expect(body.success).toBe(false);
+    expect(body.error).toContain('active agent');
+  });
+
+  it('deletes all 3 state files when present and removes from index', async () => {
+    // Create the 3 state files
+    await fs.writeFile(path.join(tmpAgentsDir, 'agent-x-state.json'), '{}');
+    await fs.writeFile(path.join(tmpAgentsDir, 'agent-x-conversations.json'), '[]');
+    await fs.writeFile(path.join(tmpAgentsDir, 'agent-x-memory.json'), '{}');
+
+    const orchestrator = makeOrchestrator({
+      agentIndex: { 'agent-x': { name: 'X' }, 'other': { name: 'Other' } }
+    });
+    const { server: s, baseUrl } = await startServer(buildApp({ orchestrator, logger }));
+    server = s;
+
+    const res = await fetch(`${baseUrl}/api/agents/archived/agent-x`, { method: 'DELETE' });
+    expect(res.status).toBe(200);
+    const body = await res.json();
+    expect(body.success).toBe(true);
+    expect(body.agentId).toBe('agent-x');
+    expect(body.deletedFiles).toHaveLength(3);
+
+    // All files should be gone
+    await expect(fs.access(path.join(tmpAgentsDir, 'agent-x-state.json'))).rejects.toThrow();
+    await expect(fs.access(path.join(tmpAgentsDir, 'agent-x-conversations.json'))).rejects.toThrow();
+    await expect(fs.access(path.join(tmpAgentsDir, 'agent-x-memory.json'))).rejects.toThrow();
+
+    // Agent index should have agent-x removed but 'other' preserved
+    const finalIndex = orchestrator.stateManager._getStoredIndex();
+    expect(finalIndex['agent-x']).toBeUndefined();
+    expect(finalIndex.other).toBeDefined();
+    expect(orchestrator.stateManager.updateAgentIndex).toHaveBeenCalled();
+  });
+
+  it('silently skips missing files (ENOENT) and reports only what was deleted', async () => {
+    // Only state file exists, no conversations or memory
+    await fs.writeFile(path.join(tmpAgentsDir, 'partial-state.json'), '{}');
+
+    const orchestrator = makeOrchestrator();
+    const { server: s, baseUrl } = await startServer(buildApp({ orchestrator, logger }));
+    server = s;
+
+    const res = await fetch(`${baseUrl}/api/agents/archived/partial`, { method: 'DELETE' });
+    expect(res.status).toBe(200);
+    const body = await res.json();
+    expect(body.success).toBe(true);
+    expect(body.deletedFiles).toHaveLength(1);
+    expect(body.deletedFiles[0]).toContain('partial-state.json');
+  });
+
+  it('does not call updateAgentIndex when agent is not in the index', async () => {
+    await fs.writeFile(path.join(tmpAgentsDir, 'orphan-state.json'), '{}');
+
+    const orchestrator = makeOrchestrator({ agentIndex: {} });
+    const { server: s, baseUrl } = await startServer(buildApp({ orchestrator, logger }));
+    server = s;
+
+    const res = await fetch(`${baseUrl}/api/agents/archived/orphan`, { method: 'DELETE' });
+    expect(res.status).toBe(200);
+    expect(orchestrator.stateManager.loadAgentIndex).toHaveBeenCalled();
+    expect(orchestrator.stateManager.updateAgentIndex).not.toHaveBeenCalled();
+  });
+
+  it('continues silently when index loading throws (try/catch swallow)', async () => {
+    await fs.writeFile(path.join(tmpAgentsDir, 'bad-index-state.json'), '{}');
+
+    const orchestrator = makeOrchestrator({ indexThrows: true });
+    const { server: s, baseUrl } = await startServer(buildApp({ orchestrator, logger }));
+    server = s;
+
+    const res = await fetch(`${baseUrl}/api/agents/archived/bad-index`, { method: 'DELETE' });
+    expect(res.status).toBe(200);
+    const body = await res.json();
+    expect(body.success).toBe(true);
+    expect(body.deletedFiles).toHaveLength(1);
+  });
+
+  it('returns 200 even when no files exist (graceful no-op)', async () => {
+    const orchestrator = makeOrchestrator();
+    const { server: s, baseUrl } = await startServer(buildApp({ orchestrator, logger }));
+    server = s;
+
+    const res = await fetch(`${baseUrl}/api/agents/archived/ghost`, { method: 'DELETE' });
+    expect(res.status).toBe(200);
+    const body = await res.json();
+    expect(body.deletedFiles).toEqual([]);
+  });
+});