fix: AgentGuard 404 in local mode, hide Settings, add rename API (#842)

* feat: UI improvements for routing, provider modal, and account preferences

- Rework provider select modal: remove model subtitles, replace badge with toggle switch, add slide transitions between list/detail views, plain back arrow, add title to detail view
- Fix provider icon colors (Anthropic, xAI) in dark mode
- Fix encryption secret fallback for local mode (getLocalAuthSecret)
- Remove Ollama from provider list
- Add editable display name field in Account Preferences (local mode)
- Hide email in header dropdown for local mode
- Move "Connect providers" button to top-right of Routing page with primary style
- Move "Disable Routing" button to left, "Setup instructions" to right
- Add confirmation modal before disabling routing
- Restructure deactivate routing modal with numbered steps
- Update terminal code blocks with light theme support (beige background, teal prompt)
- Update routing instruction modal text for clarity
- Make trash/disconnect icon neutral, Update Key button primary

* fix: resolve AgentGuard 404 in local mode and add agent rename API

- AgentGuard now waits for mode check before rendering, preventing 404 on page refresh in local mode
- Skip agent existence validation entirely in local mode (agent bootstrapped by LocalBootstrapService)
- Hide Settings tab in sidebar for local mode to prevent rename/delete of the hardcoded local agent
- Settings page redirects to overview if accessed directly in local mode
- Add PATCH /api/v1/agents/:agentName endpoint for agent renaming with conflict detection
- Add renameAgent frontend API function and wire up Settings save button

* chore: add changeset for AgentGuard local mode fix and rename API

* fix: UI polish for modals — field spacing, button alignment, provider card border

- Fix modal field spacing: use label margin-top as single source of inter-field gaps
- Remove edit icon from Change button in email provider modal
- Rename Update Key to Change and switch to outline style in provider modal
- Fix provider card border from 2px to 1px in email provider picker
- Align key-row button and disconnect icon heights to match input (2.25rem)
- Fix masked-key padding to 0 1px 0 14px
- Hide Settings link in sidebar for local mode (+ update Sidebar tests)

* fix: update tests to match current UI (toggle switches, confirm dialog, 8 providers)

- providers.test: expect 8 providers (Ollama removed)
- ProviderSelectModal.test: replace Connected/Not connected badge tests with toggle switch assertions, remove Ollama tests
- Routing.test: click confirm Disable button in deactivateAllProviders tests
- Modal field spacing and button fixes from previous commit

* test: add coverage for crypto.util, routing.service.getKeyPrefix, and aggregation.renameAgent

- crypto.util.spec: 15 tests covering getEncryptionSecret (env vars, local mode, error), encrypt/decrypt round-trip, isEncrypted
- routing.service.spec: 5 tests for getKeyPrefix (null input, decrypt success, custom length, decrypt failure)
- aggregation.service.spec: 3 tests for renameAgent (not found, conflict, transactional rename across 6 tables)

Author: SebConejo

.changeset/fix-agent-guard-local-mode.md

@@ -0,0 +1,5 @@
+---
+"manifest": patch
+---
+
+fix: resolve AgentGuard 404 on page refresh in local mode, hide Settings tab in local mode, and add agent rename API endpoint

package-lock.json

@@ -22,6 +22,7 @@ describe('AgentsController', () => {
   let mockRotateKey: jest.Mock;
   let mockConfigGet: jest.Mock;
   let mockDeleteAgent: jest.Mock;
+  let mockRenameAgent: jest.Mock;
 
   const origMode = process.env['MANIFEST_MODE'];
 
@@ -39,6 +40,7 @@ describe('AgentsController', () => {
     mockRotateKey = jest.fn().mockResolvedValue({ apiKey: 'mnfst_new_key_123' });
     mockConfigGet = jest.fn().mockReturnValue('');
     mockDeleteAgent = jest.fn().mockResolvedValue(undefined);
+    mockRenameAgent = jest.fn().mockResolvedValue(undefined);
 
     const module: TestingModule = await Test.createTestingModule({
       imports: [CacheModule.register()],
@@ -50,7 +52,7 @@ describe('AgentsController', () => {
         },
         {
           provide: AggregationService,
-          useValue: { deleteAgent: mockDeleteAgent },
+          useValue: { deleteAgent: mockDeleteAgent, renameAgent: mockRenameAgent },
         },
         {
           provide: ApiKeyGeneratorService,
@@ -125,6 +127,14 @@ describe('AgentsController', () => {
     expect(mockRotateKey).toHaveBeenCalledWith('u1', 'bot-1');
   });
 
+  it('renames agent and returns success', async () => {
+    const user = { id: 'u1' };
+    const result = await controller.renameAgent(user as never, 'bot-1', { name: 'bot-renamed' } as never);
+
+    expect(result).toEqual({ renamed: true, name: 'bot-renamed' });
+    expect(mockRenameAgent).toHaveBeenCalledWith('u1', 'bot-1', 'bot-renamed');
+  });
+
   it('deletes agent and returns success', async () => {
     const user = { id: 'u1' };
     const result = await controller.deleteAgent(user as never, 'bot-1');

packages/backend/src/analytics/controllers/agents.controller.spec.ts

@@ -1,4 +1,4 @@
-import { Body, Controller, Delete, ForbiddenException, Get, Param, Post, UseInterceptors } from '@nestjs/common';
+import { Body, Controller, Delete, ForbiddenException, Get, Param, Patch, Post, UseInterceptors } from '@nestjs/common';
 import { CacheTTL } from '@nestjs/cache-manager';
 import { ConfigService } from '@nestjs/config';
 import { TimeseriesQueriesService } from '../services/timeseries-queries.service';
@@ -7,6 +7,7 @@ import { ApiKeyGeneratorService } from '../../otlp/services/api-key.service';
 import { CurrentUser } from '../../auth/current-user.decorator';
 import { AuthUser } from '../../auth/auth.instance';
 import { CreateAgentDto } from '../../common/dto/create-agent.dto';
+import { RenameAgentDto } from '../../common/dto/rename-agent.dto';
 import { UserCacheInterceptor } from '../../common/interceptors/user-cache.interceptor';
 import { DASHBOARD_CACHE_TTL_MS } from '../../common/constants/cache.constants';
 import { readLocalApiKey } from '../../common/constants/local-mode.constants';
@@ -57,6 +58,16 @@ export class AgentsController {
     return { apiKey: result.apiKey };
   }
 
+  @Patch('agents/:agentName')
+  async renameAgent(
+    @CurrentUser() user: AuthUser,
+    @Param('agentName') agentName: string,
+    @Body() body: RenameAgentDto,
+  ) {
+    await this.aggregation.renameAgent(user.id, agentName, body.name);
+    return { renamed: true, name: body.name };
+  }
+
   @Delete('agents/:agentName')
   async deleteAgent(@CurrentUser() user: AuthUser, @Param('agentName') agentName: string) {
     if (this.config.get<string>('MANIFEST_MODE') === 'local') {

packages/backend/src/analytics/controllers/agents.controller.ts

@@ -1,6 +1,6 @@
 import { Test, TestingModule } from '@nestjs/testing';
 import { getRepositoryToken } from '@nestjs/typeorm';
-import { NotFoundException } from '@nestjs/common';
+import { ConflictException, NotFoundException } from '@nestjs/common';
 import { DataSource } from 'typeorm';
 import { AggregationService } from './aggregation.service';
 import { AgentMessage } from '../../entities/agent-message.entity';
@@ -13,6 +13,8 @@ describe('AggregationService', () => {
   let mockGetRawMany: jest.Mock;
   let mockAgentGetOne: jest.Mock;
   let mockAgentDelete: jest.Mock;
+  let mockTransaction: jest.Mock;
+  let mockAgentCreateQueryBuilder: jest.Mock;
 
   beforeEach(async () => {
     mockGetRawOne = jest.fn().mockResolvedValue({ total: 0 });
@@ -38,6 +40,8 @@ describe('AggregationService', () => {
       getOne: jest.fn().mockResolvedValue(null),
     };
 
+    mockTransaction = jest.fn().mockImplementation(async (cb: Function) => cb());
+
     const mockAgentQb = {
       select: jest.fn().mockReturnThis(),
       leftJoin: jest.fn().mockReturnThis(),
@@ -48,6 +52,8 @@ describe('AggregationService', () => {
       getMany: jest.fn().mockResolvedValue([]),
     };
 
+    mockAgentCreateQueryBuilder = jest.fn().mockReturnValue(mockAgentQb);
+
     const mockTimeseries = {
       getHourlyTokens: jest.fn().mockResolvedValue([]),
       getDailyTokens: jest.fn().mockResolvedValue([]),
@@ -71,12 +77,12 @@ describe('AggregationService', () => {
         {
           provide: getRepositoryToken(Agent),
           useValue: {
-            createQueryBuilder: jest.fn().mockReturnValue(mockAgentQb),
+            createQueryBuilder: mockAgentCreateQueryBuilder,
             delete: mockAgentDelete,
           },
         },
         { provide: TimeseriesQueriesService, useValue: mockTimeseries },
-        { provide: DataSource, useValue: { options: { type: 'postgres' } } },
+        { provide: DataSource, useValue: { options: { type: 'postgres' }, transaction: mockTransaction } },
       ],
     }).compile();
 
@@ -170,6 +176,73 @@ describe('AggregationService', () => {
     });
   });
 
+  describe('renameAgent', () => {
+    it('should throw NotFoundException when agent not found', async () => {
+      mockAgentGetOne.mockResolvedValueOnce(null);
+
+      await expect(
+        service.renameAgent('test-user', 'nonexistent', 'new-name'),
+      ).rejects.toThrow(NotFoundException);
+    });
+
+    it('should throw ConflictException when new name already exists', async () => {
+      // First call: find current agent — found
+      mockAgentGetOne.mockResolvedValueOnce({ id: 'agent-id-1', name: 'old-agent' });
+      // Second call: check for duplicate — found
+      mockAgentGetOne.mockResolvedValueOnce({ id: 'agent-id-2', name: 'taken-name' });
+
+      await expect(
+        service.renameAgent('test-user', 'old-agent', 'taken-name'),
+      ).rejects.toThrow(ConflictException);
+    });
+
+    it('should rename agent and update all related tables in a transaction', async () => {
+      // First call: find current agent — found
+      mockAgentGetOne.mockResolvedValueOnce({ id: 'agent-id-1', name: 'old-agent' });
+      // Second call: check for duplicate — not found
+      mockAgentGetOne.mockResolvedValueOnce(null);
+
+      const mockExecute = jest.fn().mockResolvedValue({});
+      const mockManagerQb = {
+        update: jest.fn().mockReturnThis(),
+        set: jest.fn().mockReturnThis(),
+        where: jest.fn().mockReturnThis(),
+        execute: mockExecute,
+      };
+
+      mockTransaction.mockImplementation(async (cb: Function) => {
+        const manager = {
+          createQueryBuilder: jest.fn().mockReturnValue(mockManagerQb),
+        };
+        return cb(manager);
+      });
+
+      await service.renameAgent('test-user', 'old-agent', 'new-agent');
+
+      // Verify transaction was called
+      expect(mockTransaction).toHaveBeenCalledTimes(1);
+
+      // The transaction callback should have executed:
+      // 1 update for agents table + 5 updates for related tables = 6 total
+      expect(mockExecute).toHaveBeenCalledTimes(6);
+
+      // Verify agents table update was called with agent id
+      expect(mockManagerQb.update).toHaveBeenCalledWith('agents');
+      expect(mockManagerQb.set).toHaveBeenCalledWith({ name: 'new-agent' });
+
+      // Verify all 5 related tables were updated
+      const updateCalls = mockManagerQb.update.mock.calls.map(
+        (c: unknown[]) => c[0],
+      );
+      expect(updateCalls).toContain('agents');
+      expect(updateCalls).toContain('agent_messages');
+      expect(updateCalls).toContain('notification_rules');
+      expect(updateCalls).toContain('notification_logs');
+      expect(updateCalls).toContain('token_usage_snapshots');
+      expect(updateCalls).toContain('cost_snapshots');
+    });
+  });
+
   describe('getMessages', () => {
     it('returns paginated messages with total count and models list', async () => {
       // count query

packages/backend/src/analytics/services/aggregation.service.spec.ts

@@ -1,4 +1,4 @@
-import { Injectable, NotFoundException } from '@nestjs/common';
+import { Injectable, ConflictException, NotFoundException } from '@nestjs/common';
 import { InjectRepository } from '@nestjs/typeorm';
 import { Brackets, DataSource, Repository } from 'typeorm';
 import { AgentMessage } from '../../entities/agent-message.entity';
@@ -142,6 +142,49 @@ export class AggregationService {
     await this.agentRepo.delete(agent.id);
   }
 
+  async renameAgent(userId: string, currentName: string, newName: string): Promise<void> {
+    const agent = await this.agentRepo
+      .createQueryBuilder('a')
+      .leftJoin('a.tenant', 't')
+      .where('t.name = :userId', { userId })
+      .andWhere('a.name = :currentName', { currentName })
+      .getOne();
+
+    if (!agent) {
+      throw new NotFoundException(`Agent "${currentName}" not found`);
+    }
+
+    const duplicate = await this.agentRepo
+      .createQueryBuilder('a')
+      .leftJoin('a.tenant', 't')
+      .where('t.name = :userId', { userId })
+      .andWhere('a.name = :newName', { newName })
+      .getOne();
+
+    if (duplicate) {
+      throw new ConflictException(`Agent "${newName}" already exists`);
+    }
+
+    await this.dataSource.transaction(async (manager) => {
+      await manager
+        .createQueryBuilder()
+        .update('agents')
+        .set({ name: newName })
+        .where('id = :id', { id: agent.id })
+        .execute();
+
+      const tables = ['agent_messages', 'notification_rules', 'notification_logs', 'token_usage_snapshots', 'cost_snapshots'];
+      for (const table of tables) {
+        await manager
+          .createQueryBuilder()
+          .update(table)
+          .set({ agent_name: newName })
+          .where('agent_name = :currentName', { currentName })
+          .execute();
+      }
+    });
+  }
+
   async getMessages(params: {
     range?: string;
     userId: string;

packages/backend/src/analytics/services/aggregation.service.ts

@@ -0,0 +1,44 @@
+import 'reflect-metadata';
+import { validate } from 'class-validator';
+import { plainToInstance } from 'class-transformer';
+import { RenameAgentDto } from './rename-agent.dto';
+
+describe('RenameAgentDto', () => {
+  it('accepts valid agent names', async () => {
+    for (const name of ['my-agent', 'agent_1', 'TestBot', 'a']) {
+      const dto = plainToInstance(RenameAgentDto, { name });
+      const errors = await validate(dto);
+      expect(errors).toHaveLength(0);
+    }
+  });
+
+  it('rejects empty name', async () => {
+    const dto = plainToInstance(RenameAgentDto, { name: '' });
+    const errors = await validate(dto);
+    expect(errors.length).toBeGreaterThan(0);
+  });
+
+  it('rejects missing name', async () => {
+    const dto = plainToInstance(RenameAgentDto, {});
+    const errors = await validate(dto);
+    expect(errors.length).toBeGreaterThan(0);
+  });
+
+  it('rejects names with spaces', async () => {
+    const dto = plainToInstance(RenameAgentDto, { name: 'has spaces' });
+    const errors = await validate(dto);
+    expect(errors.length).toBeGreaterThan(0);
+  });
+
+  it('rejects names with special characters', async () => {
+    const dto = plainToInstance(RenameAgentDto, { name: 'agent@home!' });
+    const errors = await validate(dto);
+    expect(errors.length).toBeGreaterThan(0);
+  });
+
+  it('rejects names longer than 100 characters', async () => {
+    const dto = plainToInstance(RenameAgentDto, { name: 'a'.repeat(101) });
+    const errors = await validate(dto);
+    expect(errors.length).toBeGreaterThan(0);
+  });
+});

packages/backend/src/common/dto/rename-agent.dto.spec.ts

@@ -0,0 +1,10 @@
+import { IsString, IsNotEmpty, MinLength, MaxLength, Matches } from 'class-validator';
+
+export class RenameAgentDto {
+  @IsString()
+  @IsNotEmpty()
+  @MinLength(1)
+  @MaxLength(100)
+  @Matches(/^[a-zA-Z0-9_-]+$/, { message: 'Agent name must contain only letters, numbers, dashes, and underscores' })
+  name!: string;
+}