onbuzz 4.9.1 → 4.9.7

package/src/core/agentPool.js

@@ -868,74 +868,86 @@ class AgentPool {
    */
 
   /**
-   * Delete an agent and clean up its resources
+   * Delete an agent and clean up its resources.
+   *
+   * Best-effort / idempotent: if the agent isn't currently loaded in
+   * memory we skip the live-state cleanup (attachments, visual editor,
+   * terminal processes — those only exist for loaded agents anyway)
+   * and go straight to clearing persistent state. This is how the
+   * bulk-delete UI can remove agents that were unloaded earlier in
+   * the session or that survived a process restart with no in-memory
+   * footprint. `stateManager.deleteAgentState` is itself ENOENT-safe,
+   * so deleting an already-gone agent is a no-op success.
+   *
    * @param {string} agentId - Agent identifier
    * @returns {Promise<Object>} Deletion result
    */
   async deleteAgent(agentId) {
     const agent = await this.getAgent(agentId);
-    if (!agent) {
-      throw new Error(`Agent not found: ${agentId}`);
-    }
+    const wasLoaded = !!agent;
 
-    // Clean up file attachments with reference counting
-    if (this.fileAttachmentService) {
-      try {
-        await this.fileAttachmentService.deleteAgentAttachments(agentId);
-        this.logger.info(`File attachments cleaned up for agent: ${agentId}`);
-      } catch (error) {
-        this.logger.warn(`Failed to clean up file attachments for agent: ${error.message}`, { agentId });
-        // Continue with agent deletion even if attachment cleanup fails
+    if (wasLoaded) {
+      // Clean up file attachments with reference counting
+      if (this.fileAttachmentService) {
+        try {
+          await this.fileAttachmentService.deleteAgentAttachments(agentId);
+          this.logger.info(`File attachments cleaned up for agent: ${agentId}`);
+        } catch (error) {
+          this.logger.warn(`Failed to clean up file attachments for agent: ${error.message}`, { agentId });
+          // Continue with agent deletion even if attachment cleanup fails
+        }
       }
-    }
 
-    // Clear codebase-knowledge cache for this agent — bytes live in
-    // the service's in-memory map; without this the per-agent entry
-    // would persist until the next process restart.
-    try {
-      const { getCodebaseKnowledgeService } = await import('../services/codebaseKnowledgeService.js');
-      getCodebaseKnowledgeService(this.logger).clear(agentId);
-    } catch (e) {
-      this.logger.debug?.('codebase-knowledge clear failed on agent delete', { agentId, error: e.message });
-    }
+      // Clear codebase-knowledge cache for this agent — bytes live in
+      // the service's in-memory map; without this the per-agent entry
+      // would persist until the next process restart.
+      try {
+        const { getCodebaseKnowledgeService } = await import('../services/codebaseKnowledgeService.js');
+        getCodebaseKnowledgeService(this.logger).clear(agentId);
+      } catch (e) {
+        this.logger.debug?.('codebase-knowledge clear failed on agent delete', { agentId, error: e.message });
+      }
 
-    // Clean up visual editor instance
-    try {
-      const visualEditorBridge = getVisualEditorBridge();
-      if (visualEditorBridge.hasInstance(agentId)) {
-        await visualEditorBridge.stopInstance(agentId);
-        this.logger.info(`Visual editor instance cleaned up for agent: ${agentId}`);
+      // Clean up visual editor instance
+      try {
+        const visualEditorBridge = getVisualEditorBridge();
+        if (visualEditorBridge.hasInstance(agentId)) {
+          await visualEditorBridge.stopInstance(agentId);
+          this.logger.info(`Visual editor instance cleaned up for agent: ${agentId}`);
+        }
+      } catch (error) {
+        this.logger.warn(`Failed to clean up visual editor for agent: ${error.message}`, { agentId });
       }
-    } catch (error) {
-      this.logger.warn(`Failed to clean up visual editor for agent: ${error.message}`, { agentId });
-    }
 
-    // Kill any running terminal processes for this agent
-    try {
-      const terminalTool = this.toolsRegistry?.getTool?.('terminal');
-      if (terminalTool && typeof terminalTool.cleanupAgent === 'function') {
-        await terminalTool.cleanupAgent(agentId);
-        this.logger.info(`Terminal processes cleaned up for agent: ${agentId}`);
+      // Kill any running terminal processes for this agent
+      try {
+        const terminalTool = this.toolsRegistry?.getTool?.('terminal');
+        if (terminalTool && typeof terminalTool.cleanupAgent === 'function') {
+          await terminalTool.cleanupAgent(agentId);
+          this.logger.info(`Terminal processes cleaned up for agent: ${agentId}`);
+        }
+      } catch (error) {
+        this.logger.warn(`Failed to clean up terminal processes for agent: ${error.message}`, { agentId });
       }
-    } catch (error) {
-      this.logger.warn(`Failed to clean up terminal processes for agent: ${error.message}`, { agentId });
+
+      // Clean up agent resources
+      this.agents.delete(agentId);
+      this.agentDirectory.delete(agentId);
+      this.pausedAgents.delete(agentId);
+      this.notificationQueue.delete(agentId);
     }
 
-    // Clean up agent resources
-    this.agents.delete(agentId);
-    this.agentDirectory.delete(agentId);
-    this.pausedAgents.delete(agentId);
-    this.notificationQueue.delete(agentId);
-    
-    // Clean up persistent state
+    // Clean up persistent state — runs whether or not the agent was
+    // loaded. deleteAgentState handles missing files gracefully.
     try {
       await this.stateManager.deleteAgentState(agentId);
     } catch (error) {
       this.logger.warn(`Failed to delete agent persistent state: ${error.message}`, { agentId });
     }
-    
+
     this.logger.info(`Agent deleted: ${agentId}`, {
-      agentName: agent.name,
+      agentName: agent?.name || '(not loaded)',
+      wasLoaded,
       totalAgents: this.agents.size
     });
     

package/src/core/orchestrator.js

@@ -326,30 +326,31 @@ class Orchestrator {
    */
   async _handleDeleteAgent(request) {
     const { agentId } = request.payload;
-    
+
     if (!agentId) {
       throw new Error('Agent ID is required for deletion');
     }
-    
-    // Get agent before deletion to return info
+
+    // Best-effort lookup for logging + response shape. We do NOT throw
+    // when the agent isn't loaded — that breaks bulk-delete against
+    // agents that were unloaded earlier in the session (the original
+    // implementation made the entire group operation fail with
+    // "Failed to delete N agents"). agentPool.deleteAgent now handles
+    // the unloaded case by cleaning up persistent state only.
     const agent = await this.agentPool.getAgent(agentId);
-    if (!agent) {
-      throw new Error(`Agent not found: ${agentId}`);
-    }
-    
-    // Delete the agent
+
     const result = await this.agentPool.deleteAgent(agentId);
-    
+
     this.logger.info(`Agent deleted: ${agentId}`, {
-      agentName: agent.name,
+      agentName: agent?.name || '(not loaded)',
       sessionId: request.sessionId
     });
-    
+
     return {
       success: true,
       deletedAgent: {
-        id: agent.id,
-        name: agent.name
+        id: agentId,
+        name: agent?.name || null,
       },
       ...result
     };

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

@@ -59,7 +59,7 @@ function bulkHandler(orchestrator, logger) {
           if (!agent && action !== 'delete') return { agentId, success: false, error: 'Agent not found' };
           if (actionMap[action]) {
             const payload = action === 'set-model' ? { agentId, model: params.model } : { agentId };
-            const r = await orchestrator.processRequest({ sessionId: effectiveSessionId, interface: 'WEB', action: actionMap[action], payload, projectDir });
+            const r = await orchestrator.processRequest({ sessionId: effectiveSessionId, interface: 'web', action: actionMap[action], payload, projectDir });
             return { agentId, success: r?.success !== false, error: r?.error || null };
           }
           if (action === 'enable-tool' || action === 'disable-tool') {
@@ -69,7 +69,7 @@ function bulkHandler(orchestrator, logger) {
             const i = caps.indexOf(tool);
             if (action === 'enable-tool' && i === -1) caps.push(tool);
             if (action === 'disable-tool' && i !== -1) caps.splice(i, 1);
-            const r = await orchestrator.processRequest({ sessionId: effectiveSessionId, interface: 'WEB', action: 'update_agent', payload: { agentId, updates: { capabilities: caps } }, projectDir });
+            const r = await orchestrator.processRequest({ sessionId: effectiveSessionId, interface: 'web', action: 'update_agent', payload: { agentId, updates: { capabilities: caps } }, projectDir });
             return { agentId, success: r?.success !== false, error: r?.error || null };
           }
           if (action === 'archive') {
@@ -77,7 +77,7 @@ function bulkHandler(orchestrator, logger) {
               await orchestrator.stateManager.archiveAgent(agentId, projectDir);
               return { agentId, success: true };
             }
-            const r = await orchestrator.processRequest({ sessionId: effectiveSessionId, interface: 'WEB', action: 'unload_agent', payload: { agentId }, projectDir });
+            const r = await orchestrator.processRequest({ sessionId: effectiveSessionId, interface: 'web', action: 'unload_agent', payload: { agentId }, projectDir });
             return { agentId, success: r?.success !== false, error: r?.error || null };
           }
           return { agentId, success: false, error: `Unhandled action: ${action}` };
@@ -287,4 +287,75 @@ describe('POST /api/agents/bulk — partial success', () => {
     expect(r.body.summary).toEqual({ total: 2, ok: 1, failed: 1 });
     expect(r.body.results.find(x => x.agentId === 'missing-1').error).toMatch(/not found/i);
   });
+
+  // Regression guard for the silent "Invalid interface: WEB" bug.
+  //
+  // The bulk handler used to hardcode `interface: 'WEB'` (uppercase),
+  // but orchestrator.processRequest validates against INTERFACE_TYPES
+  // — which uses LOWERCASE strings ('web', 'cli', etc.). Every bulk
+  // action — delete, pause, resume, unload, set-model, enable-tool,
+  // disable-tool, archive — failed with `Invalid interface: WEB`
+  // before even dispatching. The error was caught in `runOne`'s
+  // try/catch and surfaced as per-agent failure ("Failed to delete
+  // N agents") with no hint at the actual cause.
+  //
+  // Lock the lowercase contract for every action that flows through
+  // processRequest, so any case-drift trips this test immediately.
+  it('forwards lowercase "web" as the interface (not "WEB") for every dispatch', async () => {
+    orch = makeOrchestrator();
+    await startServer(orch);
+    // Hit one representative of each routed action.
+    await post({ action: 'delete', agentIds: ['a'] });
+    await post({ action: 'pause',  agentIds: ['a'] });
+    await post({ action: 'unload', agentIds: ['a'] });
+    await post({ action: 'set-model', agentIds: ['a'], params: { model: 'k' } });
+
+    // Every call to processRequest must have used lowercase 'web'.
+    for (const call of orch.processRequest.mock.calls) {
+      expect(call[0].interface).toBe('web');
+    }
+  });
+
+  it('falls flat if the orchestrator rejects "WEB" — regression of the original bug', async () => {
+    // Simulate the real orchestrator's validation: throw on anything
+    // not matching INTERFACE_TYPES.WEB ('web'). With the fix, every
+    // call should succeed because the handler now passes lowercase.
+    orch = makeOrchestrator({
+      processRequest: jest.fn(async ({ interface: iface }) => {
+        if (iface !== 'web') throw new Error(`Invalid interface: ${iface}`);
+        return { success: true };
+      }),
+    });
+    await startServer(orch);
+    const r = await post({ action: 'delete', agentIds: ['a', 'b'] });
+    expect(r.body.success).toBe(true);
+    expect(r.body.summary).toEqual({ total: 2, ok: 2, failed: 0 });
+  });
+
+  // Regression guard for the My Squadron > group operation (delete) bug.
+  // Before the fix, deleting selected agents in the UI failed with
+  // "Failed to delete N agents" whenever any of them was unloaded —
+  // the bulk handler let `delete` flow through to the orchestrator, but
+  // the orchestrator's _handleDeleteAgent threw "Agent not found" for
+  // anything not in the live pool. Now agentPool.deleteAgent is
+  // idempotent (clears persistent state regardless of pool membership)
+  // and the orchestrator surfaces that success up through processRequest.
+  // From the bulk route's perspective: every missing-prefixed agent
+  // should report success.
+  it('delete against missing/unloaded agents succeeds (idempotent cleanup)', async () => {
+    orch = makeOrchestrator();
+    await startServer(orch);
+    const r = await post({ action: 'delete', agentIds: ['missing-1', 'missing-2', 'a'] });
+    expect(r.status).toBe(200);
+    expect(r.body.success).toBe(true);
+    expect(r.body.summary).toEqual({ total: 3, ok: 3, failed: 0 });
+    // All three reached processRequest (no short-circuit on missing).
+    expect(orch.processRequest).toHaveBeenCalledTimes(3);
+    for (const id of ['missing-1', 'missing-2', 'a']) {
+      expect(orch.processRequest).toHaveBeenCalledWith(expect.objectContaining({
+        action: 'delete_agent',
+        payload: expect.objectContaining({ agentId: id }),
+      }));
+    }
+  });
 });

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);
+  });
+});