feat: add project management APIs with MCP config generation

Project CRUD, profile association, and MCP config generation that
filters secret env vars. 104 tests passing.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

src/mcpd/tests/mcp-config-generator.test.ts

@@ -0,0 +1,109 @@
+import { describe, it, expect } from 'vitest';
+import { generateMcpConfig } from '../src/services/mcp-config-generator.js';
+import type { ProfileWithServer } from '../src/services/mcp-config-generator.js';
+
+function makeProfile(overrides: Partial<ProfileWithServer['profile']> = {}): ProfileWithServer['profile'] {
+  return {
+    id: 'p1',
+    name: 'default',
+    serverId: 's1',
+    permissions: [],
+    envOverrides: {},
+    version: 1,
+    createdAt: new Date(),
+    updatedAt: new Date(),
+    ...overrides,
+  };
+}
+
+function makeServer(overrides: Partial<ProfileWithServer['server']> = {}): ProfileWithServer['server'] {
+  return {
+    id: 's1',
+    name: 'slack',
+    description: 'Slack MCP',
+    packageName: '@anthropic/slack-mcp',
+    dockerImage: null,
+    transport: 'STDIO',
+    repositoryUrl: null,
+    envTemplate: [],
+    version: 1,
+    createdAt: new Date(),
+    updatedAt: new Date(),
+    ...overrides,
+  };
+}
+
+describe('generateMcpConfig', () => {
+  it('returns empty mcpServers for empty profiles', () => {
+    const result = generateMcpConfig([]);
+    expect(result).toEqual({ mcpServers: {} });
+  });
+
+  it('generates config for a single profile', () => {
+    const result = generateMcpConfig([
+      { profile: makeProfile(), server: makeServer() },
+    ]);
+    expect(result.mcpServers['slack--default']).toBeDefined();
+    expect(result.mcpServers['slack--default']?.command).toBe('npx');
+    expect(result.mcpServers['slack--default']?.args).toEqual(['-y', '@anthropic/slack-mcp']);
+  });
+
+  it('excludes secret env vars from output', () => {
+    const server = makeServer({
+      envTemplate: [
+        { name: 'SLACK_BOT_TOKEN', description: 'Token', isSecret: true },
+        { name: 'SLACK_TEAM_ID', description: 'Team', isSecret: false, defaultValue: 'T123' },
+      ] as never,
+    });
+    const result = generateMcpConfig([
+      { profile: makeProfile(), server },
+    ]);
+    const config = result.mcpServers['slack--default'];
+    expect(config?.env).toBeDefined();
+    expect(config?.env?.['SLACK_TEAM_ID']).toBe('T123');
+    expect(config?.env?.['SLACK_BOT_TOKEN']).toBeUndefined();
+  });
+
+  it('applies env overrides from profile (non-secret only)', () => {
+    const server = makeServer({
+      envTemplate: [
+        { name: 'API_URL', description: 'URL', isSecret: false },
+      ] as never,
+    });
+    const profile = makeProfile({
+      envOverrides: { API_URL: 'https://staging.example.com' } as never,
+    });
+    const result = generateMcpConfig([{ profile, server }]);
+    expect(result.mcpServers['slack--default']?.env?.['API_URL']).toBe('https://staging.example.com');
+  });
+
+  it('generates multiple server configs', () => {
+    const result = generateMcpConfig([
+      { profile: makeProfile({ name: 'readonly' }), server: makeServer({ name: 'slack' }) },
+      { profile: makeProfile({ name: 'default', id: 'p2' }), server: makeServer({ name: 'github', id: 's2', packageName: '@anthropic/github-mcp' }) },
+    ]);
+    expect(Object.keys(result.mcpServers)).toHaveLength(2);
+    expect(result.mcpServers['slack--readonly']).toBeDefined();
+    expect(result.mcpServers['github--default']).toBeDefined();
+  });
+
+  it('omits env when no non-secret vars have values', () => {
+    const server = makeServer({
+      envTemplate: [
+        { name: 'TOKEN', description: 'Secret', isSecret: true },
+      ] as never,
+    });
+    const result = generateMcpConfig([
+      { profile: makeProfile(), server },
+    ]);
+    expect(result.mcpServers['slack--default']?.env).toBeUndefined();
+  });
+
+  it('uses server name as fallback when packageName is null', () => {
+    const server = makeServer({ packageName: null });
+    const result = generateMcpConfig([
+      { profile: makeProfile(), server },
+    ]);
+    expect(result.mcpServers['slack--default']?.args).toEqual(['-y', 'slack']);
+  });
+});

src/mcpd/tests/project-service.test.ts

@@ -0,0 +1,145 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { ProjectService } from '../src/services/project.service.js';
+import { NotFoundError, ConflictError } from '../src/services/mcp-server.service.js';
+import type { IProjectRepository } from '../src/repositories/project.repository.js';
+import type { IMcpProfileRepository, IMcpServerRepository } from '../src/repositories/interfaces.js';
+
+function mockProjectRepo(): IProjectRepository {
+  return {
+    findAll: vi.fn(async () => []),
+    findById: vi.fn(async () => null),
+    findByName: vi.fn(async () => null),
+    create: vi.fn(async (data) => ({
+      id: 'proj-1',
+      name: data.name,
+      description: data.description ?? '',
+      ownerId: data.ownerId,
+      version: 1,
+      createdAt: new Date(),
+      updatedAt: new Date(),
+    })),
+    update: vi.fn(async (id) => ({
+      id, name: 'test', description: '', ownerId: 'u1', version: 2,
+      createdAt: new Date(), updatedAt: new Date(),
+    })),
+    delete: vi.fn(async () => {}),
+    setProfiles: vi.fn(async () => {}),
+    getProfileIds: vi.fn(async () => []),
+  };
+}
+
+function mockProfileRepo(): IMcpProfileRepository {
+  return {
+    findAll: vi.fn(async () => []),
+    findById: vi.fn(async () => null),
+    findByServerAndName: vi.fn(async () => null),
+    create: vi.fn(async () => ({} as never)),
+    update: vi.fn(async () => ({} as never)),
+    delete: vi.fn(async () => {}),
+  };
+}
+
+function mockServerRepo(): IMcpServerRepository {
+  return {
+    findAll: vi.fn(async () => []),
+    findById: vi.fn(async () => null),
+    findByName: vi.fn(async () => null),
+    create: vi.fn(async () => ({} as never)),
+    update: vi.fn(async () => ({} as never)),
+    delete: vi.fn(async () => {}),
+  };
+}
+
+describe('ProjectService', () => {
+  let projectRepo: ReturnType<typeof mockProjectRepo>;
+  let profileRepo: ReturnType<typeof mockProfileRepo>;
+  let serverRepo: ReturnType<typeof mockServerRepo>;
+  let service: ProjectService;
+
+  beforeEach(() => {
+    projectRepo = mockProjectRepo();
+    profileRepo = mockProfileRepo();
+    serverRepo = mockServerRepo();
+    service = new ProjectService(projectRepo, profileRepo, serverRepo);
+  });
+
+  describe('create', () => {
+    it('creates a project', async () => {
+      const result = await service.create({ name: 'my-project' }, 'user-1');
+      expect(result.name).toBe('my-project');
+      expect(result.ownerId).toBe('user-1');
+    });
+
+    it('throws ConflictError when name exists', async () => {
+      vi.mocked(projectRepo.findByName).mockResolvedValue({ id: '1' } as never);
+      await expect(service.create({ name: 'taken' }, 'u1')).rejects.toThrow(ConflictError);
+    });
+
+    it('validates input', async () => {
+      await expect(service.create({ name: '' }, 'u1')).rejects.toThrow();
+    });
+  });
+
+  describe('getById', () => {
+    it('throws NotFoundError when not found', async () => {
+      await expect(service.getById('missing')).rejects.toThrow(NotFoundError);
+    });
+  });
+
+  describe('setProfiles', () => {
+    it('sets profile associations', async () => {
+      vi.mocked(projectRepo.findById).mockResolvedValue({ id: 'p1' } as never);
+      vi.mocked(profileRepo.findById).mockResolvedValue({ id: 'prof-1' } as never);
+      const result = await service.setProfiles('p1', { profileIds: ['prof-1'] });
+      expect(result).toEqual(['prof-1']);
+      expect(projectRepo.setProfiles).toHaveBeenCalledWith('p1', ['prof-1']);
+    });
+
+    it('throws NotFoundError for missing profile', async () => {
+      vi.mocked(projectRepo.findById).mockResolvedValue({ id: 'p1' } as never);
+      await expect(service.setProfiles('p1', { profileIds: ['missing'] })).rejects.toThrow(NotFoundError);
+    });
+
+    it('throws NotFoundError for missing project', async () => {
+      await expect(service.setProfiles('missing', { profileIds: [] })).rejects.toThrow(NotFoundError);
+    });
+  });
+
+  describe('getMcpConfig', () => {
+    it('returns empty config for project with no profiles', async () => {
+      vi.mocked(projectRepo.findById).mockResolvedValue({ id: 'p1' } as never);
+      const result = await service.getMcpConfig('p1');
+      expect(result).toEqual({ mcpServers: {} });
+    });
+
+    it('generates config from profiles', async () => {
+      vi.mocked(projectRepo.findById).mockResolvedValue({ id: 'p1' } as never);
+      vi.mocked(projectRepo.getProfileIds).mockResolvedValue(['prof-1']);
+      vi.mocked(profileRepo.findById).mockResolvedValue({
+        id: 'prof-1', name: 'default', serverId: 's1',
+        permissions: [], envOverrides: {},
+        version: 1, createdAt: new Date(), updatedAt: new Date(),
+      });
+      vi.mocked(serverRepo.findById).mockResolvedValue({
+        id: 's1', name: 'slack', description: '', packageName: '@anthropic/slack-mcp',
+        dockerImage: null, transport: 'STDIO', repositoryUrl: null, envTemplate: [],
+        version: 1, createdAt: new Date(), updatedAt: new Date(),
+      });
+
+      const result = await service.getMcpConfig('p1');
+      expect(result.mcpServers['slack--default']).toBeDefined();
+    });
+
+    it('throws NotFoundError for missing project', async () => {
+      await expect(service.getMcpConfig('missing')).rejects.toThrow(NotFoundError);
+    });
+  });
+
+  describe('delete', () => {
+    it('deletes project', async () => {
+      vi.mocked(projectRepo.findById).mockResolvedValue({ id: 'p1' } as never);
+      await service.delete('p1');
+      expect(projectRepo.delete).toHaveBeenCalledWith('p1');
+    });
+  });
+});