refactor(server): move the team runtime into a postponed package (P1.1)

Team mode stays in the repository but is not built or shipped (ADR-0003).

- The team server (index.ts, config, db, daemons, plugins, proactive,
  routes, scheduler, services, ws, drizzle migrations) and its tests move
  from @waggle/server to packages/team-server (@waggle/team-server,
  private). It keeps its own copies of the logger and the agent-group
  executor, so it does not import @waggle/server. @clerk/fastify, bullmq,
  ioredis, postgres, drizzle-orm, drizzle-kit, cron-parser and
  @waggle/waggle-dance leave @waggle/server; the launcher drops the same
  team-only dependencies.
- build:packages no longer builds waggle-dance or the worker: nothing in
  the community edition imports them, and the worker's project reference
  would otherwise build the team server. The worker now imports from
  team-server; the team Dockerfile builds both explicitly.
- The sidecar no longer starts the team server when DATABASE_URL is set,
  and loses the team routes (/api/team/*, /api/teams), the WaggleDance
  routes and bridge (/api/waggle-dance/*), the Team server binding and
  egress guard, the WebSocket team client, the TeamSync cache and pushes,
  team audit forwarding, team workspace registration and the team
  capability-policy lookup in chat. The in-process room signal bus stays:
  agent groups, fleet runs and external tool runs use it.
  middleware/audit.ts was dead and is deleted.
- @waggle/core loses TeamSync and the teamServer part of WaggleConfig. A
  teamServer key in config.json is ignored and kept on save, as P0.1 does
  for the tier keys. Workspaces lose teamServerUrl and teamUserId; teamId
  and teamRole stay because workspaces from a shared data directory still
  carry them and the viewer write guards read them. POST /api/workspaces
  ignores team fields.
- The sidecar bundle no longer marks the team packages as external.

The agent still references the TeamSync type in orchestrator.ts and
pattern-write-back.ts; those files are being rewritten in P1.5 and drop
it there.

Logs UF-030 and UF-031 (team sync and team policy defects found while
removing the code).
This commit is contained in:
shumeiko.it
2026-10-24 11:53:23 +02:00
parent 0cbde468a9
commit c25efe6c44
136 changed files with 450 additions and 4990 deletions

View File

@@ -0,0 +1,234 @@
import { describe, it, expect, beforeAll, afterAll } from 'vitest';
import type { FastifyRequest, FastifyReply } from 'fastify';
import { buildServer } from '../src/index.js';
import { users, teams, teamMembers, agentAuditLog } from '../src/db/schema.js';
import { sql } from 'drizzle-orm';
import { AuditService } from '../src/services/audit-service.js';
describe('Audit & Traceability (Task 3.23)', () => {
let server: Awaited<ReturnType<typeof buildServer>>;
let ownerId: string;
let memberId: string;
let teamSlug: string;
let teamId: string;
beforeAll(async () => {
server = await buildServer();
// Clean up leftover test data
await server.db.execute(sql`DELETE FROM agent_audit_log WHERE user_id IN (SELECT id FROM users WHERE clerk_id LIKE 'audit_%')`);
await server.db.execute(sql`DELETE FROM team_members WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'audit-%')`);
await server.db.execute(sql`DELETE FROM team_capability_requests WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'audit-%')`);
await server.db.execute(sql`DELETE FROM team_capability_overrides WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'audit-%')`);
await server.db.execute(sql`DELETE FROM team_capability_policies WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'audit-%')`);
await server.db.execute(sql`DELETE FROM teams WHERE slug LIKE 'audit-%'`);
await server.db.execute(sql`DELETE FROM users WHERE clerk_id LIKE 'audit_%'`);
// Create test users
const [owner] = await server.db.insert(users).values({
clerkId: 'audit_owner',
displayName: 'Audit Owner',
email: 'audit_owner@test.com',
}).returning();
ownerId = owner.id;
const [member] = await server.db.insert(users).values({
clerkId: 'audit_member',
displayName: 'Audit Member',
email: 'audit_member@test.com',
}).returning();
memberId = member.id;
// Create team
const [team] = await server.db.insert(teams).values({
name: 'Audit Test Team',
slug: 'audit-test',
ownerId,
}).returning();
teamId = team.id;
teamSlug = team.slug;
await server.db.insert(teamMembers).values([
{ teamId, userId: ownerId, role: 'owner' },
{ teamId, userId: memberId, role: 'member' },
]);
// Override auth handler for testing
server._authHandler.fn = async function (request: FastifyRequest, reply: FastifyReply) {
const testUserId = request.headers['x-test-user-id'] as string;
if (!testUserId) {
return reply.code(401).send({ error: 'Missing x-test-user-id header' });
}
request.userId = testUserId;
request.clerkId = 'test';
};
});
afterAll(async () => {
await server.db.execute(sql`DELETE FROM agent_audit_log WHERE user_id IN (SELECT id FROM users WHERE clerk_id LIKE 'audit_%')`);
await server.db.execute(sql`DELETE FROM team_members WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'audit-%')`);
await server.db.execute(sql`DELETE FROM team_capability_requests WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'audit-%')`);
await server.db.execute(sql`DELETE FROM team_capability_overrides WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'audit-%')`);
await server.db.execute(sql`DELETE FROM team_capability_policies WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'audit-%')`);
await server.db.execute(sql`DELETE FROM teams WHERE slug LIKE 'audit-%'`);
await server.db.execute(sql`DELETE FROM users WHERE clerk_id LIKE 'audit_%'`);
await server.close();
});
it('logs an audit entry via AuditService', async () => {
const auditService = new AuditService(server.db);
const entry = await auditService.log({
userId: ownerId,
teamId,
agentName: 'memory-weaver',
actionType: 'consolidation',
description: 'Consolidated 5 memory fragments into 1 summary',
beforeState: { fragmentCount: 5 },
afterState: { summaryId: 'abc123' },
});
expect(entry).toBeDefined();
expect(entry.agentName).toBe('memory-weaver');
expect(entry.actionType).toBe('consolidation');
expect(entry.description).toBe('Consolidated 5 memory fragments into 1 summary');
expect(entry.beforeState).toEqual({ fragmentCount: 5 });
expect(entry.afterState).toEqual({ summaryId: 'abc123' });
expect(entry.requiresApproval).toBe(false);
expect(entry.approved).toBeNull();
});
it('lists audit entries for team', async () => {
const response = await server.inject({
method: 'GET',
url: `/api/admin/teams/${teamSlug}/audit`,
headers: { 'x-test-user-id': ownerId },
});
expect(response.statusCode).toBe(200);
const body = JSON.parse(response.body);
expect(Array.isArray(body)).toBe(true);
expect(body.length).toBeGreaterThanOrEqual(1);
expect(body[0].agentName).toBe('memory-weaver');
});
it('filters by actionType', async () => {
// Add another entry with different actionType
const auditService = new AuditService(server.db);
await auditService.log({
userId: ownerId,
teamId,
agentName: 'scout',
actionType: 'discovery',
description: 'Found new relevant paper',
});
const response = await server.inject({
method: 'GET',
url: `/api/admin/teams/${teamSlug}/audit?actionType=discovery`,
headers: { 'x-test-user-id': ownerId },
});
expect(response.statusCode).toBe(200);
const body = JSON.parse(response.body);
expect(body.length).toBe(1);
expect(body[0].actionType).toBe('discovery');
expect(body[0].agentName).toBe('scout');
});
it('approves a pending entry', async () => {
const auditService = new AuditService(server.db);
const pending = await auditService.log({
userId: ownerId,
teamId,
agentName: 'hive-mind',
actionType: 'share_knowledge',
description: 'Share pricing analysis with team graph',
requiresApproval: true,
});
const response = await server.inject({
method: 'POST',
url: `/api/admin/teams/${teamSlug}/audit/${pending.id}/approve`,
headers: { 'x-test-user-id': ownerId },
});
expect(response.statusCode).toBe(200);
const body = JSON.parse(response.body);
expect(body.approved).toBe(true);
expect(body.approvedBy).toBe(ownerId);
});
it('rejects a pending entry', async () => {
const auditService = new AuditService(server.db);
const pending = await auditService.log({
userId: ownerId,
teamId,
agentName: 'subconscious',
actionType: 'auto_task',
description: 'Create follow-up task from meeting notes',
requiresApproval: true,
});
const response = await server.inject({
method: 'POST',
url: `/api/admin/teams/${teamSlug}/audit/${pending.id}/reject`,
headers: { 'x-test-user-id': ownerId },
});
expect(response.statusCode).toBe(200);
const body = JSON.parse(response.body);
expect(body.approved).toBe(false);
expect(body.approvedBy).toBe(ownerId);
});
it('only team admins can access audit endpoints (non-admin gets 403)', async () => {
const response = await server.inject({
method: 'GET',
url: `/api/admin/teams/${teamSlug}/audit`,
headers: { 'x-test-user-id': memberId },
});
expect(response.statusCode).toBe(403);
const body = JSON.parse(response.body);
expect(body.error).toBe('Admin access required');
});
it('returns 404 for non-existent audit entry on approve', async () => {
const fakeId = '00000000-0000-0000-0000-000000000000';
const response = await server.inject({
method: 'POST',
url: `/api/admin/teams/${teamSlug}/audit/${fakeId}/approve`,
headers: { 'x-test-user-id': ownerId },
});
expect(response.statusCode).toBe(404);
});
it('lists pending approvals', async () => {
const auditService = new AuditService(server.db);
// Create a new pending entry
await auditService.log({
userId: ownerId,
teamId,
agentName: 'hive-mind',
actionType: 'bulk_share',
description: 'Share 10 entities with team',
requiresApproval: true,
});
const response = await server.inject({
method: 'GET',
url: `/api/admin/teams/${teamSlug}/audit/pending`,
headers: { 'x-test-user-id': ownerId },
});
expect(response.statusCode).toBe(200);
const body = JSON.parse(response.body);
expect(Array.isArray(body)).toBe(true);
// All returned entries should require approval and have null approved
for (const entry of body) {
expect(entry.requiresApproval).toBe(true);
expect(entry.approved).toBeNull();
}
});
});

View File

@@ -0,0 +1,167 @@
import { createHmac } from 'node:crypto';
import { describe, it, expect, afterAll, beforeAll } from 'vitest';
import { buildServer } from '../src/index.js';
import { users } from '../src/db/schema.js';
import { sql } from 'drizzle-orm';
import { UserService } from '../src/services/user-service.js';
const SIGNING_KEY = Buffer.from('waggle-clerk-auth-integration-test-secret');
const SIGNING_SECRET = `whsec_${SIGNING_KEY.toString('base64')}`;
function signedHeaders(payload: object) {
const id = 'msg_waggle_clerk_auth_integration';
const timestamp = Math.floor(Date.now() / 1000);
const signature = createHmac('sha256', SIGNING_KEY)
.update(`${id}.${timestamp}.${JSON.stringify(payload)}`)
.digest('base64');
return {
'svix-id': id,
'svix-timestamp': String(timestamp),
'svix-signature': `v1,${signature}`,
};
}
describe('Clerk webhook', () => {
let server: Awaited<ReturnType<typeof buildServer>>;
let originalSigningSecret: string | undefined;
beforeAll(async () => {
originalSigningSecret = process.env.CLERK_WEBHOOK_SIGNING_SECRET;
process.env.CLERK_WEBHOOK_SIGNING_SECRET = SIGNING_SECRET;
server = await buildServer();
});
afterAll(async () => {
await server.db.execute(sql`DELETE FROM users WHERE clerk_id LIKE 'test_%'`);
await server.close();
if (originalSigningSecret === undefined) {
delete process.env.CLERK_WEBHOOK_SIGNING_SECRET;
} else {
process.env.CLERK_WEBHOOK_SIGNING_SECRET = originalSigningSecret;
}
});
it('creates user on user.created webhook', async () => {
const payload = {
type: 'user.created',
data: {
id: 'test_clerk_001',
first_name: 'Marko',
last_name: 'Markovic',
email_addresses: [{ email_address: 'marko@test.com' }],
image_url: 'https://example.com/avatar.jpg',
},
};
const response = await server.inject({
method: 'POST',
url: '/api/webhooks/clerk',
headers: signedHeaders(payload),
payload,
});
expect(response.statusCode).toBe(200);
const [user] = await server.db.select().from(users).where(sql`clerk_id = 'test_clerk_001'`);
expect(user).toBeDefined();
expect(user.displayName).toBe('Marko Markovic');
expect(user.email).toBe('marko@test.com');
});
it('updates user on user.updated webhook', async () => {
const payload = {
type: 'user.updated',
data: {
id: 'test_clerk_001',
first_name: 'Marko',
last_name: 'Updated',
email_addresses: [{ email_address: 'marko@test.com' }],
image_url: null,
},
};
const response = await server.inject({
method: 'POST',
url: '/api/webhooks/clerk',
headers: signedHeaders(payload),
payload,
});
expect(response.statusCode).toBe(200);
const [user] = await server.db.select().from(users).where(sql`clerk_id = 'test_clerk_001'`);
expect(user.displayName).toBe('Marko Updated');
});
it('deletes user on user.deleted webhook', async () => {
const payload = {
type: 'user.deleted',
data: {
id: 'test_clerk_001',
},
};
const response = await server.inject({
method: 'POST',
url: '/api/webhooks/clerk',
headers: signedHeaders(payload),
payload,
});
expect(response.statusCode).toBe(200);
const result = await server.db.select().from(users).where(sql`clerk_id = 'test_clerk_001'`);
expect(result).toHaveLength(0);
});
});
describe('UserService.upsertFromClerk', () => {
let server: Awaited<ReturnType<typeof buildServer>>;
let userService: UserService;
beforeAll(async () => {
server = await buildServer();
userService = new UserService(server.db);
});
afterAll(async () => {
await server.db.execute(sql`DELETE FROM users WHERE clerk_id LIKE 'test_upsert_%'`);
await server.close();
});
it('creates a new user when clerkId does not exist', async () => {
const user = await userService.upsertFromClerk({
clerkId: 'test_upsert_new',
displayName: 'New User',
email: 'new@test.com',
avatarUrl: 'https://example.com/avatar.jpg',
});
expect(user).toBeDefined();
expect(user.clerkId).toBe('test_upsert_new');
expect(user.displayName).toBe('New User');
expect(user.email).toBe('new@test.com');
expect(user.id).toBeTruthy();
});
it('updates existing user when clerkId already exists', async () => {
// First create
await userService.upsertFromClerk({
clerkId: 'test_upsert_existing',
displayName: 'Original Name',
email: 'original@test.com',
});
// Then upsert with updated data
const updated = await userService.upsertFromClerk({
clerkId: 'test_upsert_existing',
displayName: 'Updated Name',
email: 'updated@test.com',
avatarUrl: 'https://new-avatar.com/pic.jpg',
});
expect(updated.displayName).toBe('Updated Name');
expect(updated.email).toBe('updated@test.com');
expect(updated.avatarUrl).toBe('https://new-avatar.com/pic.jpg');
});
it('getByClerkId returns null for unknown clerkId', async () => {
const result = await userService.getByClerkId('nonexistent_clerk_id');
expect(result).toBeNull();
});
});

View File

@@ -0,0 +1,53 @@
import { describe, it, expect, beforeEach, afterEach } from 'vitest';
import { loadConfig } from '../src/config.js';
// Guards the CORS_ORIGIN fail-closed contract on the TEAM server config
// (packages/server/src/config.ts). The team server (index.ts) is the only
// consumer of config.corsOrigin; the desktop/local server uses the separate
// hardcoded ALLOWED_ORIGINS allowlist (local/cors-config.ts) and is unaffected.
describe('loadConfig — CORS_ORIGIN', () => {
const SAVED = {
CORS_ORIGIN: process.env.CORS_ORIGIN,
NODE_ENV: process.env.NODE_ENV,
DATABASE_URL: process.env.DATABASE_URL,
};
beforeEach(() => {
delete process.env.CORS_ORIGIN;
delete process.env.NODE_ENV;
// DATABASE_URL also fails closed in production; set it so we isolate the
// CORS_ORIGIN behavior under test.
process.env.DATABASE_URL = 'postgres://localhost:5434/waggle';
});
afterEach(() => {
for (const [k, v] of Object.entries(SAVED)) {
if (v === undefined) delete process.env[k];
else process.env[k] = v;
}
});
it('defaults to the localhost dev origin when CORS_ORIGIN is unset (non-production)', () => {
expect(loadConfig().corsOrigin).toEqual(['http://localhost:5173']);
});
it('FAILS CLOSED in production when CORS_ORIGIN is unset (no silent localhost fallback)', () => {
process.env.NODE_ENV = 'production';
expect(() => loadConfig()).toThrow(/CORS_ORIGIN.*required in production/);
});
it('parses a comma-separated list, trimming whitespace and dropping empties', () => {
process.env.NODE_ENV = 'production';
process.env.CORS_ORIGIN = 'https://app.example.com, https://admin.example.com ,';
expect(loadConfig().corsOrigin).toEqual([
'https://app.example.com',
'https://admin.example.com',
]);
});
it('accepts a single explicit origin in production', () => {
process.env.NODE_ENV = 'production';
process.env.CORS_ORIGIN = 'https://app.example.com';
expect(loadConfig().corsOrigin).toEqual(['https://app.example.com']);
});
});

View File

@@ -0,0 +1,616 @@
import { describe, it, expect, beforeAll, afterAll, vi } from 'vitest';
import { randomUUID } from 'node:crypto';
import type { FastifyRequest, FastifyReply } from 'fastify';
import { Queue } from 'bullmq';
import { buildServer } from '../src/index.js';
import { users, teams, teamMembers, cronSchedules, agentJobs } from '../src/db/schema.js';
import { sql, eq } from 'drizzle-orm';
import { CronRunner } from '../src/scheduler/cron-runner.js';
import { CronService } from '../src/services/cron-service.js';
import { JobService } from '../src/services/job-service.js';
async function waitFor(
predicate: () => Promise<boolean>,
message: string,
timeoutMs = 1_000,
): Promise<void> {
const deadline = Date.now() + timeoutMs;
while (Date.now() < deadline) {
if (await predicate()) return;
await new Promise(resolve => setTimeout(resolve, 10));
}
throw new Error(message);
}
describe('Cron Scheduler (Task 3.16)', () => {
let server: Awaited<ReturnType<typeof buildServer>>;
let ownerId: string;
let memberId: string;
let attackerId: string;
let teamSlug: string;
let teamId: string;
let attackerTeamSlug: string;
beforeAll(async () => {
server = await buildServer();
// Clean up leftover test data
await server.db.execute(sql`DELETE FROM agent_jobs WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'crontest-%')`);
await server.db.execute(sql`DELETE FROM cron_schedules WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'crontest-%')`);
await server.db.execute(sql`DELETE FROM team_members WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'crontest-%')`);
await server.db.execute(sql`DELETE FROM team_capability_requests WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'crontest-%')`);
await server.db.execute(sql`DELETE FROM team_capability_overrides WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'crontest-%')`);
await server.db.execute(sql`DELETE FROM team_capability_policies WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'crontest-%')`);
await server.db.execute(sql`DELETE FROM teams WHERE slug LIKE 'crontest-%'`);
await server.db.execute(sql`DELETE FROM users WHERE clerk_id LIKE 'crontest_%'`);
// Create test users
const [owner] = await server.db.insert(users).values({
clerkId: 'crontest_owner',
displayName: 'Cron Owner',
email: 'crontest_owner@test.com',
}).returning();
ownerId = owner.id;
const [member] = await server.db.insert(users).values({
clerkId: 'crontest_member',
displayName: 'Cron Member',
email: 'crontest_member@test.com',
}).returning();
memberId = member.id;
const [attacker] = await server.db.insert(users).values({
clerkId: 'crontest_attacker',
displayName: 'Cron Attacker',
email: 'crontest_attacker@test.com',
}).returning();
attackerId = attacker.id;
// Create team
const [team] = await server.db.insert(teams).values({
name: 'Cron Test Team',
slug: 'crontest-cron',
ownerId,
}).returning();
teamId = team.id;
teamSlug = team.slug;
const [attackerTeam] = await server.db.insert(teams).values({
name: 'Cron Attacker Team',
slug: 'crontest-attacker',
ownerId: attackerId,
}).returning();
attackerTeamSlug = attackerTeam.slug;
await server.db.insert(teamMembers).values([
{ teamId, userId: ownerId, role: 'owner' },
{ teamId, userId: memberId, role: 'member' },
{ teamId: attackerTeam.id, userId: attackerId, role: 'owner' },
]);
// Override auth handler for testing
server._authHandler.fn = async function (request: FastifyRequest, reply: FastifyReply) {
const testUserId = request.headers['x-test-user-id'] as string;
if (!testUserId) {
return reply.code(401).send({ error: 'Missing x-test-user-id header' });
}
request.userId = testUserId;
request.clerkId = 'test';
};
});
afterAll(async () => {
await server.db.execute(sql`DELETE FROM agent_jobs WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'crontest-%')`);
await server.db.execute(sql`DELETE FROM cron_schedules WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'crontest-%')`);
await server.db.execute(sql`DELETE FROM team_members WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'crontest-%')`);
await server.db.execute(sql`DELETE FROM team_capability_requests WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'crontest-%')`);
await server.db.execute(sql`DELETE FROM team_capability_overrides WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'crontest-%')`);
await server.db.execute(sql`DELETE FROM team_capability_policies WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'crontest-%')`);
await server.db.execute(sql`DELETE FROM teams WHERE slug LIKE 'crontest-%'`);
await server.db.execute(sql`DELETE FROM users WHERE clerk_id LIKE 'crontest_%'`);
await server.close();
});
it('creates a cron schedule with computed next_run_at', async () => {
const response = await server.inject({
method: 'POST',
url: `/api/teams/${teamSlug}/cron`,
headers: { 'x-test-user-id': ownerId },
payload: {
name: 'Daily Report',
cronExpr: '0 9 * * *',
jobType: 'task',
jobConfig: { prompt: 'Generate daily report' },
},
});
expect(response.statusCode).toBe(201);
const body = JSON.parse(response.body);
expect(body.name).toBe('Daily Report');
expect(body.cronExpr).toBe('0 9 * * *');
expect(body.jobType).toBe('task');
expect(body.enabled).toBe(true);
expect(body.nextRunAt).toBeTruthy();
expect(new Date(body.nextRunAt).getTime()).toBeGreaterThan(Date.now());
expect(body.lastRunAt).toBeNull();
});
it('lists schedules for team', async () => {
// Create another schedule
await server.inject({
method: 'POST',
url: `/api/teams/${teamSlug}/cron`,
headers: { 'x-test-user-id': memberId },
payload: {
name: 'Hourly Check',
cronExpr: '0 * * * *',
jobType: 'chat',
},
});
const response = await server.inject({
method: 'GET',
url: `/api/teams/${teamSlug}/cron`,
headers: { 'x-test-user-id': ownerId },
});
expect(response.statusCode).toBe(200);
const body = JSON.parse(response.body);
expect(Array.isArray(body)).toBe(true);
expect(body.length).toBeGreaterThanOrEqual(2);
});
it('returns the same not-found response for missing and foreign-team schedule ids without mutation', async () => {
const createRes = await server.inject({
method: 'POST',
url: `/api/teams/${teamSlug}/cron`,
headers: { 'x-test-user-id': ownerId },
payload: {
name: 'Victim Schedule',
cronExpr: '15 * * * *',
jobType: 'task',
},
});
const schedule = JSON.parse(createRes.body);
const foreignRes = await server.inject({
method: 'PATCH',
url: `/api/teams/${attackerTeamSlug}/cron/${schedule.id}`,
headers: { 'x-test-user-id': attackerId },
payload: { name: 'Hijacked Schedule', enabled: false },
});
const missingRes = await server.inject({
method: 'PATCH',
url: `/api/teams/${attackerTeamSlug}/cron/00000000-0000-4000-8000-000000000001`,
headers: { 'x-test-user-id': attackerId },
payload: { enabled: false },
});
expect(foreignRes.statusCode).toBe(404);
expect(foreignRes.json()).toEqual({ error: 'Schedule not found' });
expect(missingRes.statusCode).toBe(404);
expect(missingRes.json()).toEqual(foreignRes.json());
const [persisted] = await server.db.select().from(cronSchedules)
.where(eq(cronSchedules.id, schedule.id));
expect(persisted.name).toBe('Victim Schedule');
expect(persisted.enabled).toBe(true);
});
it('disables a schedule via PATCH', async () => {
// Create a schedule to disable
const createRes = await server.inject({
method: 'POST',
url: `/api/teams/${teamSlug}/cron`,
headers: { 'x-test-user-id': ownerId },
payload: {
name: 'To Disable',
cronExpr: '*/30 * * * *',
jobType: 'task',
},
});
const schedule = JSON.parse(createRes.body);
expect(schedule.enabled).toBe(true);
const patchRes = await server.inject({
method: 'PATCH',
url: `/api/teams/${teamSlug}/cron/${schedule.id}`,
headers: { 'x-test-user-id': ownerId },
payload: { enabled: false },
});
expect(patchRes.statusCode).toBe(200);
const updated = JSON.parse(patchRes.body);
expect(updated.enabled).toBe(false);
});
it.each(['cron', 'shell'])('rejects unsupported scheduled job type %s before persistence', async (jobType) => {
const name = `Unsupported ${jobType}`;
const response = await server.inject({
method: 'POST',
url: `/api/teams/${teamSlug}/cron`,
headers: { 'x-test-user-id': ownerId },
payload: {
name,
cronExpr: '0 4 * * *',
jobType,
},
});
expect(response.statusCode).toBe(400);
const schedules = await server.db.select().from(cronSchedules)
.where(eq(cronSchedules.teamId, teamId));
expect(schedules.some(schedule => schedule.name === name)).toBe(false);
});
it('CronService refuses unsupported job types outside route validation', async () => {
const cronService = new CronService(server.db);
await expect(cronService.create(teamId, ownerId, {
name: 'Direct Unsafe Schedule',
cronExpr: '0 5 * * *',
jobType: 'shell',
})).rejects.toThrow('Unsupported scheduled job type: shell');
const schedules = await server.db.select().from(cronSchedules)
.where(eq(cronSchedules.teamId, teamId));
expect(schedules.some(schedule => schedule.name === 'Direct Unsafe Schedule')).toBe(false);
});
it('CronRunner.tick() picks up due schedule and queues job', async () => {
// Snapshot job count before tick
const jobsBefore = await server.db.select().from(agentJobs)
.where(eq(agentJobs.teamId, teamId));
const beforeCount = jobsBefore.length;
// Create a schedule with next_run_at in the past so it's immediately due
const pastDate = new Date(Date.now() - 60_000);
await server.db.insert(cronSchedules).values({
teamId,
createdBy: ownerId,
name: 'Due Now',
cronExpr: '* * * * *', // every minute
jobType: 'task',
jobConfig: { prompt: 'Cron runner test' },
enabled: true,
nextRunAt: pastDate,
}).returning();
const runner = new CronRunner(server.db, server.jobService);
const count = await runner.tick();
expect(count).toBeGreaterThanOrEqual(1);
// Verify our specific job was created
const jobsAfter = await server.db.select().from(agentJobs)
.where(eq(agentJobs.teamId, teamId));
const cronJob = jobsAfter.find(j => (j.input as { prompt?: string }).prompt === 'Cron runner test');
expect(cronJob).toBeTruthy();
expect(cronJob!.jobType).toBe('task');
expect(cronJob!.status).toBe('queued');
expect(jobsAfter.length).toBeGreaterThan(beforeCount);
});
it('updates last_run_at and next_run_at after tick', async () => {
// Create a due schedule
const pastDate = new Date(Date.now() - 120_000);
const [schedule] = await server.db.insert(cronSchedules).values({
teamId,
createdBy: ownerId,
name: 'Check After Tick',
cronExpr: '*/5 * * * *', // every 5 minutes
jobType: 'chat',
jobConfig: {},
enabled: true,
nextRunAt: pastDate,
}).returning();
const runner = new CronRunner(server.db, server.jobService);
await runner.tick();
// Re-read the schedule
const [updated] = await server.db.select().from(cronSchedules)
.where(eq(cronSchedules.id, schedule.id));
expect(updated.lastRunAt).toBeTruthy();
expect(new Date(updated.lastRunAt!).getTime()).toBeGreaterThan(pastDate.getTime());
expect(updated.nextRunAt).toBeTruthy();
expect(new Date(updated.nextRunAt!).getTime()).toBeGreaterThan(Date.now());
});
it('runs due schedules through the Fastify lifecycle without a manual tick', async () => {
const lifecycleConfig = { port: 0 };
const lifecycleServer = await buildServer(lifecycleConfig);
const marker = `lifecycle-${Date.now()}`;
let scheduleId: string | undefined;
try {
const [schedule] = await lifecycleServer.db.insert(cronSchedules).values({
teamId,
createdBy: ownerId,
name: 'Lifecycle Due Schedule',
cronExpr: '* * * * *',
jobType: 'task',
jobConfig: { marker, prompt: 'Lifecycle cron test' },
enabled: true,
nextRunAt: new Date(Date.now() - 60_000),
}).returning();
scheduleId = schedule.id;
expect(schedule.lastRunAt).toBeNull();
await lifecycleServer.ready();
await waitFor(async () => {
const [persisted] = await lifecycleServer.db.select().from(cronSchedules)
.where(eq(cronSchedules.id, schedule.id));
return persisted?.lastRunAt !== null;
}, 'Fastify lifecycle did not advance the due cron schedule');
const [advanced] = await lifecycleServer.db.select().from(cronSchedules)
.where(eq(cronSchedules.id, schedule.id));
expect(advanced.nextRunAt?.getTime()).toBeGreaterThan(Date.now());
const jobs = await lifecycleServer.db.select().from(agentJobs)
.where(eq(agentJobs.teamId, teamId));
expect(jobs.some(job => (job.input as { marker?: string }).marker === marker)).toBe(true);
} finally {
const jobs = await lifecycleServer.db.select().from(agentJobs)
.where(eq(agentJobs.teamId, teamId));
for (const job of jobs.filter(item => (item.input as { marker?: string }).marker === marker)) {
await lifecycleServer.jobService.cancelJob(job.id);
}
if (scheduleId) {
await lifecycleServer.db.delete(cronSchedules)
.where(eq(cronSchedules.id, scheduleId));
}
await lifecycleServer.close();
}
});
it('skips a legacy invalid cron expression before queueing and continues later schedules', async () => {
const pastDate = new Date(Date.now() - 60_000);
const invalidMarker = `invalid-cron-${Date.now()}`;
const validMarker = `valid-after-invalid-${Date.now()}`;
const [invalidSchedule] = await server.db.insert(cronSchedules).values({
teamId,
createdBy: ownerId,
name: 'Legacy Invalid Cron',
cronExpr: 'not a cron expression',
jobType: 'task',
jobConfig: { marker: invalidMarker },
enabled: true,
nextRunAt: pastDate,
}).returning();
const [validSchedule] = await server.db.insert(cronSchedules).values({
teamId,
createdBy: ownerId,
name: 'Valid After Invalid Cron',
cronExpr: '* * * * *',
jobType: 'task',
jobConfig: { marker: validMarker },
enabled: true,
nextRunAt: pastDate,
}).returning();
const errors: unknown[] = [];
const runner = new CronRunner(server.db, server.jobService, error => errors.push(error));
let validJob: typeof agentJobs.$inferSelect | undefined;
try {
await expect(runner.tick()).resolves.toBe(1);
const jobs = await server.db.select().from(agentJobs)
.where(eq(agentJobs.teamId, teamId));
expect(jobs.some(job => (job.input as { marker?: string }).marker === invalidMarker)).toBe(false);
validJob = jobs.find(job => (job.input as { marker?: string }).marker === validMarker);
expect(validJob?.status).toBe('queued');
expect(errors).toHaveLength(1);
const [persistedInvalid] = await server.db.select().from(cronSchedules)
.where(eq(cronSchedules.id, invalidSchedule.id));
expect(persistedInvalid.lastRunAt).toBeNull();
expect(persistedInvalid.nextRunAt?.getTime()).toBe(pastDate.getTime());
} finally {
if (validJob) await server.jobService.cancelJob(validJob.id);
await server.db.delete(cronSchedules).where(eq(cronSchedules.id, invalidSchedule.id));
await server.db.delete(cronSchedules).where(eq(cronSchedules.id, validSchedule.id));
}
});
it('deduplicates one due occurrence across concurrent runners', async () => {
const marker = `concurrent-occurrence-${Date.now()}`;
const [schedule] = await server.db.insert(cronSchedules).values({
teamId,
createdBy: ownerId,
name: 'Concurrent Occurrence',
cronExpr: '* * * * *',
jobType: 'task',
jobConfig: { marker },
enabled: true,
nextRunAt: new Date(Date.now() - 60_000),
}).returning();
const originalCreate = server.jobService.createJob.bind(server.jobService);
let arrivals = 0;
let release!: () => void;
const bothSelected = new Promise<void>(resolve => { release = resolve; });
const createSpy = vi.spyOn(server.jobService, 'createJob').mockImplementation(async (...args) => {
arrivals++;
if (arrivals === 2) release();
await bothSelected;
return originalCreate(...args);
});
let jobs: Array<typeof agentJobs.$inferSelect> = [];
try {
const first = new CronRunner(server.db, server.jobService);
const second = new CronRunner(server.db, server.jobService);
const counts = await Promise.all([first.tick(), second.tick()]);
jobs = (await server.db.select().from(agentJobs)
.where(eq(agentJobs.teamId, teamId)))
.filter(job => (job.input as { marker?: string }).marker === marker);
expect(jobs).toHaveLength(1);
expect(counts[0] + counts[1]).toBe(1);
} finally {
createSpy.mockRestore();
for (const job of jobs) await server.jobService.cancelJob(job.id);
await server.db.delete(cronSchedules).where(eq(cronSchedules.id, schedule.id));
}
});
it('reuses the same occurrence job after a post-enqueue schedule-update failure', async () => {
const marker = `retry-occurrence-${Date.now()}`;
const [schedule] = await server.db.insert(cronSchedules).values({
teamId,
createdBy: ownerId,
name: 'Retry Occurrence',
cronExpr: '* * * * *',
jobType: 'task',
jobConfig: { marker },
enabled: true,
nextRunAt: new Date(Date.now() - 60_000),
}).returning();
const errors: unknown[] = [];
const runner = new CronRunner(server.db, server.jobService, error => errors.push(error));
const updateSpy = vi.spyOn(server.db, 'update').mockImplementationOnce(() => {
throw new Error('simulated schedule update failure');
});
let jobs: Array<typeof agentJobs.$inferSelect> = [];
try {
try {
expect(await runner.tick()).toBe(0);
expect(errors).toHaveLength(1);
} finally {
updateSpy.mockRestore();
}
expect(await runner.tick()).toBe(1);
jobs = (await server.db.select().from(agentJobs)
.where(eq(agentJobs.teamId, teamId)))
.filter(job => (job.input as { marker?: string }).marker === marker);
expect(jobs).toHaveLength(1);
} finally {
for (const job of jobs) await server.jobService.cancelJob(job.id);
await server.db.delete(cronSchedules).where(eq(cronSchedules.id, schedule.id));
}
});
it('queues the persisted canonical payload when an occurrence retry input differs', async () => {
const queueName = `cron-canonical-${Date.now()}`;
const redisUrl = new URL(process.env.REDIS_URL ?? 'redis://localhost:6381');
const jobService = new JobService(server.db, redisUrl.href, queueName);
const queue = new Queue(queueName, {
connection: {
host: redisUrl.hostname,
port: parseInt(redisUrl.port || '6379', 10),
},
});
const jobId = randomUUID();
try {
await jobService.createJob(teamId, ownerId, 'task', { marker: 'canonical' }, jobId);
const firstQueueJob = await queue.getJob(jobId);
expect(firstQueueJob).toBeTruthy();
await firstQueueJob!.remove();
await jobService.createJob(teamId, ownerId, 'task', { marker: 'conflicting-retry' }, jobId);
const [persisted] = await server.db.select().from(agentJobs)
.where(eq(agentJobs.id, jobId));
const retriedQueueJob = await queue.getJob(jobId);
expect(persisted.input).toEqual({ marker: 'canonical' });
expect(retriedQueueJob?.data.input).toEqual(persisted.input);
} finally {
const queued = await queue.getJob(jobId);
if (queued) await queued.remove();
await server.db.delete(agentJobs).where(eq(agentJobs.id, jobId));
await queue.close();
await jobService.close();
}
});
it('skips an unsafe legacy schedule while queueing an allowed due schedule', async () => {
const pastDate = new Date(Date.now() - 60_000);
const [unsafeSchedule, validSchedule] = await server.db.insert(cronSchedules).values([
{
teamId,
createdBy: ownerId,
name: 'Legacy Recursive Cron',
cronExpr: '* * * * *',
jobType: 'cron',
jobConfig: { marker: 'blocked-recursive-cron' },
enabled: true,
nextRunAt: pastDate,
},
{
teamId,
createdBy: ownerId,
name: 'Allowed Due Chat',
cronExpr: '* * * * *',
jobType: 'chat',
jobConfig: { marker: 'allowed-due-chat', message: 'Scheduled read-only check' },
enabled: true,
nextRunAt: pastDate,
},
]).returning();
const runner = new CronRunner(server.db, server.jobService);
let unsafeJob: typeof agentJobs.$inferSelect | undefined;
let validJob: typeof agentJobs.$inferSelect | undefined;
try {
const count = await runner.tick();
const jobs = await server.db.select().from(agentJobs)
.where(eq(agentJobs.teamId, teamId));
unsafeJob = jobs.find(job => (job.input as { marker?: string }).marker === 'blocked-recursive-cron');
validJob = jobs.find(job => (job.input as { marker?: string }).marker === 'allowed-due-chat');
expect(count).toBe(1);
expect(unsafeJob).toBeUndefined();
expect(validJob?.jobType).toBe('chat');
const [persistedUnsafe] = await server.db.select().from(cronSchedules)
.where(eq(cronSchedules.id, unsafeSchedule.id));
const [persistedValid] = await server.db.select().from(cronSchedules)
.where(eq(cronSchedules.id, validSchedule.id));
expect(persistedUnsafe.lastRunAt).toBeNull();
expect(persistedUnsafe.nextRunAt?.getTime()).toBe(pastDate.getTime());
expect(persistedValid.lastRunAt).toBeTruthy();
expect(persistedValid.nextRunAt!.getTime()).toBeGreaterThan(Date.now());
} finally {
if (unsafeJob) await server.jobService.cancelJob(unsafeJob.id);
if (validJob) await server.jobService.cancelJob(validJob.id);
}
});
it('rejects invalid cron expression', async () => {
const response = await server.inject({
method: 'POST',
url: `/api/teams/${teamSlug}/cron`,
headers: { 'x-test-user-id': ownerId },
payload: {
name: 'Bad Cron',
cronExpr: 'not a cron',
jobType: 'task',
},
});
expect(response.statusCode).toBe(400);
});
it('non-member gets 403', async () => {
// Create an outsider
const [outsider] = await server.db.insert(users).values({
clerkId: 'crontest_outsider',
displayName: 'Cron Outsider',
email: 'crontest_outsider@test.com',
}).returning();
const response = await server.inject({
method: 'GET',
url: `/api/teams/${teamSlug}/cron`,
headers: { 'x-test-user-id': outsider.id },
});
expect(response.statusCode).toBe(403);
});
});

View File

@@ -0,0 +1,170 @@
import { describe, it, expect, beforeAll, afterAll } from 'vitest';
import { buildServer } from '../../src/index.js';
import { users, teams, teamMembers, teamResources, agentJobs, tasks, messages } from '../../src/db/schema.js';
import { sql, eq } from 'drizzle-orm';
import { HiveMindAgent } from '../../src/daemons/hive-mind.js';
describe('Hive Mind Agent (Task 3.20)', () => {
let server: Awaited<ReturnType<typeof buildServer>>;
let ownerId: string;
let memberId: string;
let teamId: string;
let hiveMind: HiveMindAgent;
beforeAll(async () => {
server = await buildServer();
// Clean up leftover test data
await server.db.execute(sql`DELETE FROM messages WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'hivetest-%')`);
await server.db.execute(sql`DELETE FROM agent_jobs WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'hivetest-%')`);
await server.db.execute(sql`DELETE FROM tasks WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'hivetest-%')`);
await server.db.execute(sql`DELETE FROM team_resources WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'hivetest-%')`);
await server.db.execute(sql`DELETE FROM team_members WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'hivetest-%')`);
await server.db.execute(sql`DELETE FROM team_capability_requests WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'hivetest-%')`);
await server.db.execute(sql`DELETE FROM team_capability_overrides WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'hivetest-%')`);
await server.db.execute(sql`DELETE FROM team_capability_policies WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'hivetest-%')`);
await server.db.execute(sql`DELETE FROM teams WHERE slug LIKE 'hivetest-%'`);
await server.db.execute(sql`DELETE FROM users WHERE clerk_id LIKE 'hive_%'`);
// Create test users
const [owner] = await server.db.insert(users).values({
clerkId: 'hive_owner',
displayName: 'Hive Owner',
email: 'hive_owner@test.com',
}).returning();
ownerId = owner.id;
const [member] = await server.db.insert(users).values({
clerkId: 'hive_member',
displayName: 'Hive Member',
email: 'hive_member@test.com',
}).returning();
memberId = member.id;
// Create team
const [team] = await server.db.insert(teams).values({
name: 'Hive Test Team',
slug: 'hivetest-team',
ownerId,
}).returning();
teamId = team.id;
await server.db.insert(teamMembers).values([
{ teamId, userId: ownerId, role: 'owner' },
{ teamId, userId: memberId, role: 'member' },
]);
// Seed data: completed jobs
await server.db.insert(agentJobs).values(
Array.from({ length: 5 }, (_, i) => ({
teamId,
userId: ownerId,
jobType: 'chat',
status: 'completed',
input: { prompt: `job ${i}` },
completedAt: new Date(),
})),
);
// Seed data: tasks with similar titles by different users (duplicate work)
await server.db.insert(tasks).values([
{ teamId, title: 'Setup CI/CD pipeline for backend', status: 'done', createdBy: ownerId },
{ teamId, title: 'Setup CI/CD pipeline for frontend', status: 'done', createdBy: memberId },
{ teamId, title: 'Write unit tests', status: 'done', createdBy: ownerId },
]);
// Seed data: team resources with ratings
await server.db.insert(teamResources).values([
{
teamId,
resourceType: 'prompt_template',
name: 'Best Code Review Prompt',
description: 'A highly rated code review template',
config: {},
sharedBy: ownerId,
rating: 4.5,
},
{
teamId,
resourceType: 'skill',
name: 'Low Rated Skill',
description: 'Not very useful',
config: {},
sharedBy: memberId,
rating: 1.0,
},
]);
hiveMind = new HiveMindAgent(server.db);
});
afterAll(async () => {
await server.db.execute(sql`DELETE FROM messages WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'hivetest-%')`);
await server.db.execute(sql`DELETE FROM agent_jobs WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'hivetest-%')`);
await server.db.execute(sql`DELETE FROM tasks WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'hivetest-%')`);
await server.db.execute(sql`DELETE FROM team_resources WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'hivetest-%')`);
await server.db.execute(sql`DELETE FROM team_members WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'hivetest-%')`);
await server.db.execute(sql`DELETE FROM team_capability_requests WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'hivetest-%')`);
await server.db.execute(sql`DELETE FROM team_capability_overrides WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'hivetest-%')`);
await server.db.execute(sql`DELETE FROM team_capability_policies WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'hivetest-%')`);
await server.db.execute(sql`DELETE FROM teams WHERE slug LIKE 'hivetest-%'`);
await server.db.execute(sql`DELETE FROM users WHERE clerk_id LIKE 'hive_%'`);
await server.close();
});
it('generates weekly digest with metrics', async () => {
const { digest, messageId } = await hiveMind.generateWeeklyDigest(teamId);
expect(digest).toBeTruthy();
expect(digest.metrics.jobsCompleted).toBe(5);
expect(digest.metrics.tasksCompleted).toBe(3);
expect(digest.metrics.resourcesShared).toBe(2);
expect(digest.period.from).toBeInstanceOf(Date);
expect(digest.period.to).toBeInstanceOf(Date);
expect(messageId).toBeTruthy();
});
it('detects duplicate work across team members', async () => {
const { digest } = await hiveMind.generateWeeklyDigest(teamId);
// "Setup CI/CD pipeline" tasks by different users should be detected
expect(digest.duplicateWork.length).toBeGreaterThan(0);
const duplicate = digest.duplicateWork[0];
expect(duplicate.users.length).toBe(2);
expect(duplicate.titles.length).toBe(2);
});
it('identifies best practices from high-rated resources', async () => {
const { digest } = await hiveMind.generateWeeklyDigest(teamId);
// Only the high-rated resource (4.5 >= 3.0) should appear
expect(digest.bestPractices.length).toBe(1);
expect(digest.bestPractices[0].name).toBe('Best Code Review Prompt');
expect(digest.bestPractices[0].rating).toBe(4.5);
});
it('generates recommendations based on findings', async () => {
const { digest } = await hiveMind.generateWeeklyDigest(teamId);
// Should have duplicate work recommendation
expect(digest.recommendations.length).toBeGreaterThan(0);
expect(digest.recommendations.some(r => r.includes('duplicate'))).toBe(true);
// Should have best practices recommendation
expect(digest.recommendations.some(r => r.includes('highly-rated'))).toBe(true);
});
it('broadcasts digest as a waggle dance message', async () => {
const { messageId } = await hiveMind.generateWeeklyDigest(teamId);
// Verify the message was stored
const [msg] = await server.db.select().from(messages)
.where(eq(messages.id, messageId));
expect(msg).toBeTruthy();
expect(msg.type).toBe('broadcast');
expect(msg.subtype).toBe('discovery');
const digestContent = msg.content as { type: string; digest: unknown };
expect(digestContent.type).toBe('weekly_digest');
expect(digestContent.digest).toBeTruthy();
});
});

View File

@@ -0,0 +1,223 @@
import { describe, it, expect, beforeAll, afterAll } from 'vitest';
import type { FastifyRequest, FastifyReply } from 'fastify';
import { buildServer } from '../../src/index.js';
import { users, teams, teamMembers, teamResources, agents, scoutFindings } from '../../src/db/schema.js';
import { sql, eq } from 'drizzle-orm';
import { ScoutAgent } from '../../src/daemons/scout.js';
describe('Scout Agent (Task 3.18)', () => {
let server: Awaited<ReturnType<typeof buildServer>>;
let userId: string;
let secondUserId: string;
let teamId: string;
let scout: ScoutAgent;
beforeAll(async () => {
server = await buildServer();
// Clean up leftover test data
await server.db.execute(sql`DELETE FROM scout_findings WHERE user_id IN (SELECT id FROM users WHERE clerk_id LIKE 'scout_%')`);
await server.db.execute(sql`DELETE FROM agents WHERE user_id IN (SELECT id FROM users WHERE clerk_id LIKE 'scout_%')`);
await server.db.execute(sql`DELETE FROM team_resources WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'scouttest-%')`);
await server.db.execute(sql`DELETE FROM team_members WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'scouttest-%')`);
await server.db.execute(sql`DELETE FROM team_capability_requests WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'scouttest-%')`);
await server.db.execute(sql`DELETE FROM team_capability_overrides WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'scouttest-%')`);
await server.db.execute(sql`DELETE FROM team_capability_policies WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'scouttest-%')`);
await server.db.execute(sql`DELETE FROM teams WHERE slug LIKE 'scouttest-%'`);
await server.db.execute(sql`DELETE FROM users WHERE clerk_id LIKE 'scout_%'`);
// Create test user
const [user] = await server.db.insert(users).values({
clerkId: 'scout_user1',
displayName: 'Scout User',
email: 'scout_user1@test.com',
}).returning();
userId = user.id;
const [secondUser] = await server.db.insert(users).values({
clerkId: 'scout_user2',
displayName: 'Scout User 2',
email: 'scout_user2@test.com',
}).returning();
secondUserId = secondUser.id;
// Create team
const [team] = await server.db.insert(teams).values({
name: 'Scout Test Team',
slug: 'scouttest-team',
ownerId: userId,
}).returning();
teamId = team.id;
// Add membership with interests
await server.db.insert(teamMembers).values({
teamId,
userId,
role: 'owner',
interests: ['python', 'data-science'],
});
// Create an agent with tools for the user
await server.db.insert(agents).values({
userId,
teamId,
name: 'TestAgent',
tools: ['web_search', 'code_review'],
});
// Create team resources
await server.db.insert(teamResources).values([
{
teamId,
resourceType: 'skill',
name: 'Python Data Analyzer',
description: 'A skill for analyzing data with Python',
config: {},
sharedBy: userId,
},
{
teamId,
resourceType: 'prompt_template',
name: 'Code Review Template',
description: 'Template for code reviews',
config: {},
sharedBy: userId,
},
]);
scout = new ScoutAgent(server.db);
// Override auth handler
server._authHandler.fn = async function (request: FastifyRequest, reply: FastifyReply) {
const testUserId = request.headers['x-test-user-id'] as string;
if (!testUserId) {
return reply.code(401).send({ error: 'Missing x-test-user-id header' });
}
request.userId = testUserId;
request.clerkId = 'test';
};
});
afterAll(async () => {
await server.db.execute(sql`DELETE FROM scout_findings WHERE user_id IN (SELECT id FROM users WHERE clerk_id LIKE 'scout_%')`);
await server.db.execute(sql`DELETE FROM agents WHERE user_id IN (SELECT id FROM users WHERE clerk_id LIKE 'scout_%')`);
await server.db.execute(sql`DELETE FROM team_resources WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'scouttest-%')`);
await server.db.execute(sql`DELETE FROM team_members WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'scouttest-%')`);
await server.db.execute(sql`DELETE FROM team_capability_requests WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'scouttest-%')`);
await server.db.execute(sql`DELETE FROM team_capability_overrides WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'scouttest-%')`);
await server.db.execute(sql`DELETE FROM team_capability_policies WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'scouttest-%')`);
await server.db.execute(sql`DELETE FROM teams WHERE slug LIKE 'scouttest-%'`);
await server.db.execute(sql`DELETE FROM users WHERE clerk_id LIKE 'scout_%'`);
await server.close();
});
it('scan creates findings from team resources', async () => {
const findings = await scout.scan(userId, teamId);
expect(findings.length).toBeGreaterThanOrEqual(2);
expect(findings.every((f) => f.status === 'new')).toBe(true);
expect(findings.some((f) => f.title.includes('Python Data Analyzer'))).toBe(true);
expect(findings.some((f) => f.title.includes('Code Review Template'))).toBe(true);
});
it('relevance scoring boosts based on user interests', async () => {
// The Python Data Analyzer should be boosted because user has 'python' interest
const findings = await scout.listFindings(userId);
const pythonFinding = findings.find((f) => f.title.includes('Python'));
const templateFinding = findings.find((f) => f.title.includes('Code Review'));
expect(pythonFinding).toBeTruthy();
expect(templateFinding).toBeTruthy();
// Python finding should have higher score (base 0.5 + 0.3 interest boost)
expect(pythonFinding!.relevanceScore).toBeGreaterThan(templateFinding!.relevanceScore);
});
it('adopt updates status', async () => {
const findings = await scout.listFindings(userId);
const finding = findings[0];
const updated = await scout.adopt(finding.id, userId);
expect(updated).toBeTruthy();
expect(updated!.status).toBe('adopted');
});
it('dismiss updates status', async () => {
const findings = await scout.listFindings(userId);
const newFinding = findings.find((f) => f.status === 'new');
expect(newFinding).toBeTruthy();
const updated = await scout.dismiss(newFinding!.id, userId);
expect(updated).toBeTruthy();
expect(updated!.status).toBe('dismissed');
});
it('dismissed finding not resurfaced in future scans', async () => {
// Clear all non-dismissed findings
const allFindings = await scout.listFindings(userId);
const dismissed = allFindings.filter((f) => f.status === 'dismissed');
expect(dismissed.length).toBeGreaterThan(0);
// Run scan again — dismissed titles should not reappear as new
const newFindings = await scout.scan(userId, teamId);
const dismissedTitles = dismissed.map((f) => f.title);
const resurfaced = newFindings.filter((f) => dismissedTitles.includes(f.title));
expect(resurfaced.length).toBe(0);
});
it('GET /api/scout/findings returns findings for user', async () => {
const response = await server.inject({
method: 'GET',
url: '/api/scout/findings',
headers: { 'x-test-user-id': userId },
});
expect(response.statusCode).toBe(200);
const body = JSON.parse(response.body);
expect(Array.isArray(body)).toBe(true);
expect(body.length).toBeGreaterThan(0);
});
it.each(['adopted', 'dismissed'] as const)(
'does not let one user mark another user\'s finding as %s',
async (status) => {
const [victimFinding] = await server.db.insert(scoutFindings).values({
userId: secondUserId,
teamId,
source: 'team',
category: 'practice',
title: `Victim finding ${status}`,
summary: 'belongs to another user',
relevanceScore: 0.8,
url: null,
status: 'new',
}).returning();
const response = await server.inject({
method: 'PATCH',
url: `/api/scout/findings/${victimFinding.id}`,
headers: { 'x-test-user-id': userId },
payload: { status },
});
expect(response.statusCode).toBe(404);
expect(response.json()).toEqual({ error: 'Finding not found' });
const [unchanged] = await server.db.select().from(scoutFindings)
.where(eq(scoutFindings.id, victimFinding.id));
expect(unchanged.status).toBe('new');
expect(unchanged.userId).toBe(secondUserId);
},
);
it('PATCH /api/scout/findings/:id rejects invalid status', async () => {
const findings = await scout.listFindings(userId);
const finding = findings[0];
const response = await server.inject({
method: 'PATCH',
url: `/api/scout/findings/${finding.id}`,
headers: { 'x-test-user-id': userId },
payload: { status: 'invalid' },
});
expect(response.statusCode).toBe(400);
});
});

View File

@@ -0,0 +1,130 @@
import { describe, it, expect, beforeAll, afterAll } from 'vitest';
import { buildServer } from '../../src/index.js';
import { users, teams, teamMembers, agentJobs, agentAuditLog } from '../../src/db/schema.js';
import { sql } from 'drizzle-orm';
import { SubconsciousAgent } from '../../src/daemons/subconscious.js';
describe('Subconscious Agent (Task 3.19)', () => {
let server: Awaited<ReturnType<typeof buildServer>>;
let userId: string;
let teamId: string;
let subconscious: SubconsciousAgent;
beforeAll(async () => {
server = await buildServer();
// Clean up leftover test data
await server.db.execute(sql`DELETE FROM agent_audit_log WHERE user_id IN (SELECT id FROM users WHERE clerk_id LIKE 'subcon_%')`);
await server.db.execute(sql`DELETE FROM agent_jobs WHERE user_id IN (SELECT id FROM users WHERE clerk_id LIKE 'subcon_%')`);
await server.db.execute(sql`DELETE FROM team_members WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'subcontest-%')`);
await server.db.execute(sql`DELETE FROM team_capability_requests WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'subcontest-%')`);
await server.db.execute(sql`DELETE FROM team_capability_overrides WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'subcontest-%')`);
await server.db.execute(sql`DELETE FROM team_capability_policies WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'subcontest-%')`);
await server.db.execute(sql`DELETE FROM teams WHERE slug LIKE 'subcontest-%'`);
await server.db.execute(sql`DELETE FROM users WHERE clerk_id LIKE 'subcon_%'`);
// Create test user
const [user] = await server.db.insert(users).values({
clerkId: 'subcon_user1',
displayName: 'Subconscious User',
email: 'subcon_user1@test.com',
}).returning();
userId = user.id;
// Create team
const [team] = await server.db.insert(teams).values({
name: 'Subconscious Test Team',
slug: 'subcontest-team',
ownerId: userId,
}).returning();
teamId = team.id;
await server.db.insert(teamMembers).values({
teamId,
userId,
role: 'owner',
});
subconscious = new SubconsciousAgent(server.db);
});
afterAll(async () => {
await server.db.execute(sql`DELETE FROM agent_audit_log WHERE user_id IN (SELECT id FROM users WHERE clerk_id LIKE 'subcon_%')`);
await server.db.execute(sql`DELETE FROM agent_jobs WHERE user_id IN (SELECT id FROM users WHERE clerk_id LIKE 'subcon_%')`);
await server.db.execute(sql`DELETE FROM team_members WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'subcontest-%')`);
await server.db.execute(sql`DELETE FROM team_capability_requests WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'subcontest-%')`);
await server.db.execute(sql`DELETE FROM team_capability_overrides WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'subcontest-%')`);
await server.db.execute(sql`DELETE FROM team_capability_policies WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'subcontest-%')`);
await server.db.execute(sql`DELETE FROM teams WHERE slug LIKE 'subcontest-%'`);
await server.db.execute(sql`DELETE FROM users WHERE clerk_id LIKE 'subcon_%'`);
await server.close();
});
it('shouldReflect returns false when under threshold', async () => {
// No completed jobs yet
const result = await subconscious.shouldReflect(userId);
expect(result).toBe(false);
});
it('shouldReflect returns true after N completed jobs', async () => {
// Insert 10 completed jobs (SUBCONSCIOUS_INTERACTION_THRESHOLD = 10)
const jobValues = Array.from({ length: 10 }, (_, i) => ({
teamId,
userId,
jobType: 'chat',
status: 'completed',
input: { prompt: `test ${i}` },
completedAt: new Date(),
}));
await server.db.insert(agentJobs).values(jobValues);
const result = await subconscious.shouldReflect(userId);
expect(result).toBe(true);
});
it('reflect creates audit entry', async () => {
const { auditEntry, insights } = await subconscious.reflect(userId);
expect(auditEntry).toBeTruthy();
expect(auditEntry.agentName).toBe('subconscious');
expect(auditEntry.actionType).toBe('subconscious_reflection');
expect(auditEntry.description).toContain('Reflected on');
expect(Array.isArray(insights)).toBe(true);
});
it('detects repeated job types pattern', async () => {
// Insert 5 more jobs of same type to trigger pattern detection
const repeatedJobs = Array.from({ length: 5 }, (_, i) => ({
teamId,
userId,
jobType: 'task',
status: 'completed',
input: { prompt: `repeated ${i}` },
completedAt: new Date(),
}));
await server.db.insert(agentJobs).values(repeatedJobs);
const { insights } = await subconscious.reflect(userId);
// Should find a prompt_change insight for the repeated 'chat' type (10 jobs)
const promptInsight = insights.find(i => i.type === 'prompt_change');
expect(promptInsight).toBeTruthy();
expect(promptInsight!.description).toContain('executed');
expect(promptInsight!.description).toContain('times recently');
});
it('prompt change insight requires approval in audit entry', async () => {
// The previous reflect should have created an audit entry with requiresApproval
const entries = await server.db.select().from(agentAuditLog)
.where(sql`${agentAuditLog.userId} = ${userId} AND ${agentAuditLog.actionType} = 'subconscious_reflection'`);
// Find one that has insights with prompt_change
const withApproval = entries.find(e => {
const state = e.afterState as { insights?: Array<{ type: string }> } | null;
return state?.insights?.some((i) => i.type === 'prompt_change');
});
expect(withApproval).toBeTruthy();
expect(withApproval!.requiresApproval).toBe(true);
});
});

View File

@@ -0,0 +1,93 @@
import { describe, it, expect, beforeAll, afterAll } from 'vitest';
import { createDb, type Db } from '../../src/db/connection.js';
import { users, teams, teamMembers, tasks, messages, agents, agentGroups } from '../../src/db/schema.js';
import { sql } from 'drizzle-orm';
const SUFFIX = `_schema_${Date.now()}`;
describe('PostgreSQL schema', () => {
let db: Db;
let testUserId: string;
let testTeamId: string;
beforeAll(async () => {
db = createDb(process.env.DATABASE_URL ?? 'postgres://waggle:waggle_dev@localhost:5434/waggle');
// Clean up any leftovers from previous runs
await db.execute(sql`DELETE FROM team_members WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE '%_schema_%')`);
await db.execute(sql`DELETE FROM team_capability_requests WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE '%_schema_%')`);
await db.execute(sql`DELETE FROM team_capability_overrides WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE '%_schema_%')`);
await db.execute(sql`DELETE FROM team_capability_policies WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE '%_schema_%')`);
await db.execute(sql`DELETE FROM teams WHERE slug LIKE '%_schema_%'`);
await db.execute(sql`DELETE FROM users WHERE clerk_id LIKE '%_schema_%'`);
});
afterAll(async () => {
// Clean up test data created by these tests
if (testTeamId) {
await db.execute(sql`DELETE FROM team_members WHERE team_id = ${testTeamId}`);
await db.execute(sql`DELETE FROM team_capability_requests WHERE team_id = ${testTeamId}`);
await db.execute(sql`DELETE FROM team_capability_overrides WHERE team_id = ${testTeamId}`);
await db.execute(sql`DELETE FROM team_capability_policies WHERE team_id = ${testTeamId}`);
await db.execute(sql`DELETE FROM teams WHERE id = ${testTeamId}`);
}
if (testUserId) {
await db.execute(sql`DELETE FROM users WHERE id = ${testUserId}`);
}
});
it('creates a user', async () => {
const [user] = await db.insert(users).values({
clerkId: `clerk${SUFFIX}`,
displayName: 'Schema Test User',
email: `schematest${SUFFIX}@test.com`,
}).returning();
testUserId = user.id;
expect(user.id).toBeDefined();
expect(user.displayName).toBe('Schema Test User');
});
it('creates a team with owner', async () => {
// Depends on previous test having created user
expect(testUserId).toBeTruthy();
const [team] = await db.insert(teams).values({
name: 'Marketing',
slug: `marketing${SUFFIX}`,
ownerId: testUserId,
}).returning();
testTeamId = team.id;
expect(team.slug).toBe(`marketing${SUFFIX}`);
await db.insert(teamMembers).values({
teamId: team.id,
userId: testUserId,
role: 'owner',
});
});
it('creates all 16 tables', async () => {
const result = await db.execute(sql`
SELECT table_name FROM information_schema.tables
WHERE table_schema = 'public' AND table_type = 'BASE TABLE'
ORDER BY table_name
`);
const tableNames = (result as Array<{ table_name: string }>).map((r) => r.table_name);
expect(tableNames).toContain('users');
expect(tableNames).toContain('teams');
expect(tableNames).toContain('team_members');
expect(tableNames).toContain('agents');
expect(tableNames).toContain('agent_groups');
expect(tableNames).toContain('tasks');
expect(tableNames).toContain('messages');
expect(tableNames).toContain('team_entities');
expect(tableNames).toContain('team_relations');
expect(tableNames).toContain('team_resources');
expect(tableNames).toContain('agent_jobs');
expect(tableNames).toContain('cron_schedules');
expect(tableNames).toContain('scout_findings');
expect(tableNames).toContain('proactive_patterns');
expect(tableNames).toContain('suggestions_log');
expect(tableNames).toContain('agent_audit_log');
});
});

View File

@@ -0,0 +1,139 @@
/**
* Team Server E2E — tests the multi-user team server running on Docker
* (Postgres + Redis + LiteLLM).
*
* Requires: docker-compose up (postgres:5434, redis:6381, litellm:4000)
* Team server running on port 3100.
*/
import { test, expect } from '@playwright/test';
const TEAM = 'http://127.0.0.1:3100';
test.beforeEach(async ({ request }) => {
try {
const res = await request.get(`${TEAM}/health`, { timeout: 1_000 });
test.skip(!res.ok(), 'Optional team server is not running on 127.0.0.1:3100');
} catch {
test.skip(true, 'Optional team server is not running on 127.0.0.1:3100');
}
});
// ── 1. Server Health ──────────────────────────────────────────────────
test.describe('1. Team Server Health', () => {
test('health endpoint responds', async ({ request }) => {
const res = await request.get(`${TEAM}/health`);
expect(res.ok()).toBeTruthy();
const data = await res.json();
expect(data.status).toBe('ok');
});
});
// ── 2. Team CRUD ──────────────────────────────────────────────────────
test.describe('2. Team Management', () => {
let teamSlug: string;
test('can create a team', async ({ request }) => {
const name = `TestTeam-${Date.now()}`;
teamSlug = name.toLowerCase().replace(/[^a-z0-9]/g, '-');
const res = await request.post(`${TEAM}/api/teams`, {
data: { name, slug: teamSlug },
headers: { 'Content-Type': 'application/json' },
});
// May need auth — accept 200, 201, or 401
expect([200, 201, 401, 403]).toContain(res.status());
});
test('can list teams', async ({ request }) => {
const res = await request.get(`${TEAM}/api/teams`);
expect([200, 401, 403]).toContain(res.status());
if (res.ok()) {
const data = await res.json();
expect(Array.isArray(data) || Array.isArray(data.teams)).toBeTruthy();
}
});
});
// ── 3. Agent Routes ───────────────────────────────────────────────────
test.describe('3. Agent & Model Routes', () => {
test('agents list', async ({ request }) => {
const res = await request.get(`${TEAM}/api/agents`);
expect([200, 401]).toContain(res.status());
});
test('workflows list', async ({ request }) => {
const res = await request.get(`${TEAM}/api/workflows`);
expect([200, 401, 404]).toContain(res.status());
});
});
// ── 4. Database Connection ────────────────────────────────────────────
test.describe('4. Database', () => {
test('postgres is reachable from server', async ({ request }) => {
// The server started successfully which means DB connected.
// Verify by hitting an endpoint that requires DB.
const res = await request.get(`${TEAM}/api/teams`);
// If 500, DB connection failed. 200 or 401 means DB is fine.
expect(res.status()).not.toBe(500);
});
});
// ── 5. WebSocket Gateway ──────────────────────────────────────────────
test.describe('5. WebSocket', () => {
test('ws endpoint exists', async ({ request }) => {
// HTTP GET to /ws should return upgrade required or similar
const res = await request.get(`${TEAM}/ws`);
// WebSocket endpoints typically return 400 or 426 on plain HTTP
expect([400, 404, 426]).toContain(res.status());
});
});
// ── 6. Cron & Jobs ────────────────────────────────────────────────────
test.describe('6. Background Services', () => {
test('cron status endpoint', async ({ request }) => {
const res = await request.get(`${TEAM}/api/cron`);
expect([200, 401, 404]).toContain(res.status());
});
});
// ── 7. Knowledge & Resources ──────────────────────────────────────────
test.describe('7. Knowledge Routes', () => {
test('skills endpoint', async ({ request }) => {
const res = await request.get(`${TEAM}/api/skills`);
expect([200, 401, 404]).toContain(res.status());
});
});
// ── 8. Concurrent Requests ────────────────────────────────────────────
test.describe('8. Concurrency', () => {
test('10 concurrent health checks all succeed', async ({ request }) => {
const results = await Promise.all(
Array.from({ length: 10 }, () => request.get(`${TEAM}/health`))
);
for (const res of results) {
expect(res.ok()).toBeTruthy();
}
});
test('server handles rapid API calls without crashing', async ({ request }) => {
const endpoints = ['/health', '/api/teams', '/api/agents', '/api/workflows', '/api/cron'];
const results = await Promise.all(
endpoints.map(ep => request.get(`${TEAM}${ep}`))
);
// No 500s — server survived the burst
for (const res of results) {
expect(res.status()).toBeLessThan(500);
}
// Health still ok after burst
const health = await request.get(`${TEAM}/health`);
expect(health.ok()).toBeTruthy();
});
});

View File

@@ -0,0 +1,35 @@
import { describe, expect, it } from 'vitest';
import { readFileSync } from 'node:fs';
import { resolve } from 'node:path';
import { fileURLToPath, pathToFileURL } from 'node:url';
import { isDirectModule } from '../src/index.js';
const REPO_ROOT = fileURLToPath(new URL('../../../', import.meta.url));
describe('team server entrypoint detection', () => {
it('is left out of the community-edition package build with the rest of team mode (ADR-0003)', () => {
const rootPackage = JSON.parse(readFileSync(resolve(REPO_ROOT, 'package.json'), 'utf8')) as {
scripts: Record<string, string>;
};
const build = rootPackage.scripts['build:packages'];
expect(build).toContain('cd ../server && npx tsc --build');
for (const postponed of ['../team-server', '../worker', '../waggle-dance']) {
expect(build).not.toContain(postponed);
}
});
it('recognizes the compiled dist entrypoint by URL identity', () => {
const distPath = resolve(REPO_ROOT, 'packages/team-server/dist/index.js');
expect(isDirectModule(distPath, pathToFileURL(distPath).href)).toBe(true);
});
it('does not start when imported by another process entrypoint', () => {
const distPath = resolve(REPO_ROOT, 'packages/team-server/dist/index.js');
const importerUrl = pathToFileURL(resolve(REPO_ROOT, 'packages/team-server/dist/consumer.js')).href;
expect(isDirectModule(distPath, importerUrl)).toBe(false);
expect(isDirectModule(undefined, importerUrl)).toBe(false);
});
});

View File

@@ -0,0 +1,292 @@
import { createHmac } from 'node:crypto';
import { describe, it, expect, beforeAll, afterAll } from 'vitest';
import type { FastifyRequest, FastifyReply } from 'fastify';
import { buildServer } from '../../src/index.js';
import {
users, teams, teamMembers, tasks, messages,
teamEntities, teamResources, agentAuditLog,
} from '../../src/db/schema.js';
import { sql } from 'drizzle-orm';
const SIGNING_KEY = Buffer.from('waggle-m3-full-stack-test-secret');
const SIGNING_SECRET = `whsec_${SIGNING_KEY.toString('base64')}`;
function signedHeaders(payload: object) {
const id = 'msg_waggle_m3_full_stack';
const timestamp = Math.floor(Date.now() / 1000);
const signature = createHmac('sha256', SIGNING_KEY)
.update(`${id}.${timestamp}.${JSON.stringify(payload)}`)
.digest('base64');
return {
'svix-id': id,
'svix-timestamp': String(timestamp),
'svix-signature': `v1,${signature}`,
};
}
describe('M3 Full Stack Integration', () => {
let server: Awaited<ReturnType<typeof buildServer>>;
let ownerId: string;
let memberId: string;
let teamId: string;
let originalSigningSecret: string | undefined;
const teamSlug = 'integ-team';
beforeAll(async () => {
originalSigningSecret = process.env.CLERK_WEBHOOK_SIGNING_SECRET;
process.env.CLERK_WEBHOOK_SIGNING_SECRET = SIGNING_SECRET;
server = await buildServer();
// Clean up leftover test data from previous runs (reverse dependency order)
await server.db.execute(sql`DELETE FROM agent_audit_log WHERE user_id IN (SELECT id FROM users WHERE clerk_id LIKE 'integ_%')`);
await server.db.execute(sql`DELETE FROM team_resources WHERE team_id IN (SELECT id FROM teams WHERE slug = 'integ-team')`);
await server.db.execute(sql`DELETE FROM team_relations WHERE team_id IN (SELECT id FROM teams WHERE slug = 'integ-team')`);
await server.db.execute(sql`DELETE FROM team_entities WHERE team_id IN (SELECT id FROM teams WHERE slug = 'integ-team')`);
await server.db.execute(sql`DELETE FROM messages WHERE team_id IN (SELECT id FROM teams WHERE slug = 'integ-team')`);
await server.db.execute(sql`DELETE FROM tasks WHERE team_id IN (SELECT id FROM teams WHERE slug = 'integ-team')`);
await server.db.execute(sql`DELETE FROM agent_jobs WHERE team_id IN (SELECT id FROM teams WHERE slug = 'integ-team')`);
await server.db.execute(sql`DELETE FROM cron_schedules WHERE team_id IN (SELECT id FROM teams WHERE slug = 'integ-team')`);
await server.db.execute(sql`DELETE FROM team_members WHERE team_id IN (SELECT id FROM teams WHERE slug = 'integ-team')`);
await server.db.execute(sql`DELETE FROM team_capability_requests WHERE team_id IN (SELECT id FROM teams WHERE slug = 'integ-team')`);
await server.db.execute(sql`DELETE FROM team_capability_overrides WHERE team_id IN (SELECT id FROM teams WHERE slug = 'integ-team')`);
await server.db.execute(sql`DELETE FROM team_capability_policies WHERE team_id IN (SELECT id FROM teams WHERE slug = 'integ-team')`);
await server.db.execute(sql`DELETE FROM teams WHERE slug = 'integ-team'`);
await server.db.execute(sql`DELETE FROM users WHERE clerk_id LIKE 'integ_%'`);
// Override auth handler for testing
server._authHandler.fn = async function (request: FastifyRequest, reply: FastifyReply) {
const testUserId = request.headers['x-test-user-id'] as string;
if (!testUserId) {
return reply.code(401).send({ error: 'Missing x-test-user-id header' });
}
request.userId = testUserId;
request.clerkId = 'test';
};
});
afterAll(async () => {
try {
// Clean up all test data
await server.db.execute(sql`DELETE FROM agent_audit_log WHERE user_id IN (SELECT id FROM users WHERE clerk_id LIKE 'integ_%')`);
await server.db.execute(sql`DELETE FROM team_resources WHERE team_id IN (SELECT id FROM teams WHERE slug = 'integ-team')`);
await server.db.execute(sql`DELETE FROM team_relations WHERE team_id IN (SELECT id FROM teams WHERE slug = 'integ-team')`);
await server.db.execute(sql`DELETE FROM team_entities WHERE team_id IN (SELECT id FROM teams WHERE slug = 'integ-team')`);
await server.db.execute(sql`DELETE FROM messages WHERE team_id IN (SELECT id FROM teams WHERE slug = 'integ-team')`);
await server.db.execute(sql`DELETE FROM tasks WHERE team_id IN (SELECT id FROM teams WHERE slug = 'integ-team')`);
await server.db.execute(sql`DELETE FROM agent_jobs WHERE team_id IN (SELECT id FROM teams WHERE slug = 'integ-team')`);
await server.db.execute(sql`DELETE FROM cron_schedules WHERE team_id IN (SELECT id FROM teams WHERE slug = 'integ-team')`);
await server.db.execute(sql`DELETE FROM team_members WHERE team_id IN (SELECT id FROM teams WHERE slug = 'integ-team')`);
await server.db.execute(sql`DELETE FROM team_capability_requests WHERE team_id IN (SELECT id FROM teams WHERE slug = 'integ-team')`);
await server.db.execute(sql`DELETE FROM team_capability_overrides WHERE team_id IN (SELECT id FROM teams WHERE slug = 'integ-team')`);
await server.db.execute(sql`DELETE FROM team_capability_policies WHERE team_id IN (SELECT id FROM teams WHERE slug = 'integ-team')`);
await server.db.execute(sql`DELETE FROM teams WHERE slug = 'integ-team'`);
await server.db.execute(sql`DELETE FROM users WHERE clerk_id LIKE 'integ_%'`);
} finally {
try {
await server?.close();
} finally {
if (originalSigningSecret === undefined) {
delete process.env.CLERK_WEBHOOK_SIGNING_SECRET;
} else {
process.env.CLERK_WEBHOOK_SIGNING_SECRET = originalSigningSecret;
}
}
}
});
it('Step 1: Creates users via webhook', async () => {
// Create owner
const ownerEvent = {
type: 'user.created',
data: {
id: 'integ_owner',
first_name: 'Owner',
last_name: 'User',
email_addresses: [{ email_address: 'integ_owner@test.com' }],
},
};
let res = await server.inject({
method: 'POST',
url: '/api/webhooks/clerk',
headers: signedHeaders(ownerEvent),
payload: ownerEvent,
});
expect(res.statusCode).toBe(200);
// Create member
const memberEvent = {
type: 'user.created',
data: {
id: 'integ_member',
first_name: 'Member',
last_name: 'User',
email_addresses: [{ email_address: 'integ_member@test.com' }],
},
};
res = await server.inject({
method: 'POST',
url: '/api/webhooks/clerk',
headers: signedHeaders(memberEvent),
payload: memberEvent,
});
expect(res.statusCode).toBe(200);
// Get user IDs
const [owner] = await server.db.select().from(users).where(sql`clerk_id = 'integ_owner'`);
const [member] = await server.db.select().from(users).where(sql`clerk_id = 'integ_member'`);
expect(owner).toBeDefined();
expect(member).toBeDefined();
ownerId = owner.id;
memberId = member.id;
});
it('Step 2: Creates team and invites member', async () => {
let res = await server.inject({
method: 'POST',
url: '/api/teams',
headers: { 'x-test-user-id': ownerId },
payload: { name: 'Integration Team', slug: teamSlug },
});
expect(res.statusCode).toBe(201);
teamId = JSON.parse(res.body).id;
// Add member
res = await server.inject({
method: 'POST',
url: `/api/teams/${teamSlug}/members`,
headers: { 'x-test-user-id': ownerId },
payload: { email: 'integ_member@test.com', role: 'member' },
});
expect(res.statusCode).toBe(201);
});
it('Step 3: Creates task on team board', async () => {
const res = await server.inject({
method: 'POST',
url: `/api/teams/${teamSlug}/tasks`,
headers: { 'x-test-user-id': ownerId },
payload: { title: 'Research competitor pricing', priority: 'high' },
});
expect(res.statusCode).toBe(201);
const body = JSON.parse(res.body);
expect(body.title).toBe('Research competitor pricing');
expect(body.priority).toBe('high');
expect(body.status).toBe('open');
});
it('Step 4: Sends Waggle Dance message', async () => {
const res = await server.inject({
method: 'POST',
url: `/api/teams/${teamSlug}/messages`,
headers: { 'x-test-user-id': ownerId },
payload: {
type: 'request',
subtype: 'knowledge_check',
content: { topic: 'competitor pricing' },
},
});
expect(res.statusCode).toBe(201);
const body = JSON.parse(res.body);
expect(body.type).toBe('request');
expect(body.subtype).toBe('knowledge_check');
});
it('Step 5: Shares knowledge entity to team graph', async () => {
const res = await server.inject({
method: 'POST',
url: `/api/teams/${teamSlug}/entities`,
headers: { 'x-test-user-id': ownerId },
payload: { entityType: 'competitor', name: 'Acme Corp', properties: { pricing: '$99/mo' } },
});
expect(res.statusCode).toBe(201);
const body = JSON.parse(res.body);
expect(body.entityType).toBe('competitor');
expect(body.name).toBe('Acme Corp');
});
it('Step 6: Shares team resource', async () => {
const res = await server.inject({
method: 'POST',
url: `/api/teams/${teamSlug}/resources`,
headers: { 'x-test-user-id': ownerId },
payload: {
resourceType: 'model_recipe',
name: 'Fast Research Config',
config: { model: 'claude-haiku-4-5', temperature: 0.3 },
},
});
expect(res.statusCode).toBe(201);
const body = JSON.parse(res.body);
expect(body.resourceType).toBe('model_recipe');
expect(body.name).toBe('Fast Research Config');
});
it('Step 7: Creates audit trail entry', async () => {
const { AuditService } = await import('../../src/services/audit-service.js');
const auditService = new AuditService(server.db);
const entry = await auditService.log({
userId: ownerId,
teamId,
agentName: 'memory-weaver',
actionType: 'consolidation',
description: 'Consolidated meeting notes',
});
expect(entry.agentName).toBe('memory-weaver');
// Verify via admin API
// First promote owner to admin role (owner already has admin+ perms)
const res = await server.inject({
method: 'GET',
url: `/api/admin/teams/${teamSlug}/audit`,
headers: { 'x-test-user-id': ownerId },
});
expect(res.statusCode).toBe(200);
const body = JSON.parse(res.body);
expect(body.length).toBeGreaterThanOrEqual(1);
});
it('Step 8: Member cannot access admin audit endpoint', async () => {
const res = await server.inject({
method: 'GET',
url: `/api/admin/teams/${teamSlug}/audit`,
headers: { 'x-test-user-id': memberId },
});
expect(res.statusCode).toBe(403);
});
it('Step 9: Lists tasks, messages, entities for the team', async () => {
// Tasks
const tasksRes = await server.inject({
method: 'GET',
url: `/api/teams/${teamSlug}/tasks`,
headers: { 'x-test-user-id': memberId },
});
expect(tasksRes.statusCode).toBe(200);
expect(JSON.parse(tasksRes.body).length).toBeGreaterThanOrEqual(1);
// Messages
const msgsRes = await server.inject({
method: 'GET',
url: `/api/teams/${teamSlug}/messages`,
headers: { 'x-test-user-id': memberId },
});
expect(msgsRes.statusCode).toBe(200);
expect(JSON.parse(msgsRes.body).length).toBeGreaterThanOrEqual(1);
// Entities
const entRes = await server.inject({
method: 'GET',
url: `/api/teams/${teamSlug}/entities`,
headers: { 'x-test-user-id': memberId },
});
expect(entRes.statusCode).toBe(200);
expect(JSON.parse(entRes.body).length).toBeGreaterThanOrEqual(1);
});
it('Step 10: Health check passes', async () => {
const res = await server.inject({ method: 'GET', url: '/health' });
expect(res.statusCode).toBe(200);
expect(JSON.parse(res.body).status).toBe('ok');
});
});

View File

@@ -0,0 +1,220 @@
import { describe, it, expect, beforeAll, afterAll } from 'vitest';
import type { FastifyRequest, FastifyReply } from 'fastify';
import { buildServer } from '../src/index.js';
import { users, proactivePatterns, suggestionsLog } from '../src/db/schema.js';
import { sql, eq } from 'drizzle-orm';
import { ProactiveService } from '../src/services/proactive-service.js';
describe('Proactive Engine (Task 3.17)', () => {
let server: Awaited<ReturnType<typeof buildServer>>;
let userId: string;
let secondUserId: string;
let proactiveService: ProactiveService;
beforeAll(async () => {
server = await buildServer();
// Clean up leftover test data
await server.db.execute(sql`DELETE FROM suggestions_log WHERE user_id IN (SELECT id FROM users WHERE clerk_id LIKE 'protest_%')`);
await server.db.execute(sql`DELETE FROM proactive_patterns WHERE name LIKE 'test_%'`);
await server.db.execute(sql`DELETE FROM users WHERE clerk_id LIKE 'protest_%'`);
// Also clean any seeded patterns for a clean slate
await server.db.execute(sql`DELETE FROM suggestions_log`);
await server.db.execute(sql`DELETE FROM proactive_patterns`);
// Create test users
const [user] = await server.db.insert(users).values({
clerkId: 'protest_user1',
displayName: 'Proactive User',
email: 'protest_user1@test.com',
}).returning();
userId = user.id;
const [user2] = await server.db.insert(users).values({
clerkId: 'protest_user2',
displayName: 'Proactive User 2',
email: 'protest_user2@test.com',
}).returning();
secondUserId = user2.id;
proactiveService = new ProactiveService(server.db);
// Seed patterns
await proactiveService.ensurePatternsSeeded();
// Override auth handler
server._authHandler.fn = async function (request: FastifyRequest, reply: FastifyReply) {
const testUserId = request.headers['x-test-user-id'] as string;
if (!testUserId) {
return reply.code(401).send({ error: 'Missing x-test-user-id header' });
}
request.userId = testUserId;
request.clerkId = 'test';
};
});
afterAll(async () => {
await server.db.execute(sql`DELETE FROM suggestions_log WHERE user_id IN (SELECT id FROM users WHERE clerk_id LIKE 'protest_%')`);
await server.db.execute(sql`DELETE FROM proactive_patterns`);
await server.db.execute(sql`DELETE FROM users WHERE clerk_id LIKE 'protest_%'`);
await server.close();
});
it('seeds built-in patterns', async () => {
const patterns = await server.db.select().from(proactivePatterns);
expect(patterns.length).toBe(5);
const names = patterns.map(p => p.name);
expect(names).toContain('recurring_task');
expect(names).toContain('data_report');
expect(names).toContain('relevant_to_others');
expect(names).toContain('expensive_model');
expect(names).toContain('manual_repetition');
});
it('does not re-seed if patterns exist', async () => {
await proactiveService.ensurePatternsSeeded();
const patterns = await server.db.select().from(proactivePatterns);
expect(patterns.length).toBe(5); // still 5, not 10
});
it('pattern triggers create suggestion when context matches', async () => {
const result = await proactiveService.evaluate(userId, {
repeatCount: 5, // triggers 'recurring_task' (cron) pattern
});
expect(result).toBeTruthy();
expect(result!.status).toBe('pending');
expect(result!.pattern.suggestionType).toBe('cron');
});
it('max 1 suggestion per interaction (second evaluate returns null)', async () => {
// User already has a pending suggestion from previous test
const result = await proactiveService.evaluate(userId, {
hasData: true, // would trigger 'data_report' (dashboard) pattern
});
expect(result).toBeNull();
});
it('dismissed pattern not re-suggested', async () => {
// Clear all pending suggestions for secondUserId so we start fresh
await server.db.execute(sql`DELETE FROM suggestions_log WHERE user_id = ${secondUserId}`);
// First, trigger a suggestion for secondUserId
const suggestion = await proactiveService.evaluate(secondUserId, {
repeatCount: 4, // triggers cron pattern
});
expect(suggestion).toBeTruthy();
// Dismiss it
await proactiveService.updateStatus(suggestion!.id, secondUserId, 'dismissed');
// Clear pending count so the MAX check doesn't block us
// (dismissed doesn't count as pending, so evaluate should proceed)
// Try to trigger the same pattern again
const result2 = await proactiveService.evaluate(secondUserId, {
repeatCount: 10,
});
// Should be null because the cron pattern was dismissed
// It might match a different pattern though, so check specifically
if (result2) {
expect(result2.pattern.suggestionType).not.toBe('cron');
}
});
it('accept/dismiss/snooze updates status via API', async () => {
// Clear suggestions for userId
await server.db.execute(sql`DELETE FROM suggestions_log WHERE user_id = ${userId}`);
// Create a new suggestion
const suggestion = await proactiveService.evaluate(userId, {
expensiveModel: true, // triggers 'upgrade' pattern
});
expect(suggestion).toBeTruthy();
// Accept via API
const response = await server.inject({
method: 'PATCH',
url: `/api/suggestions/${suggestion!.id}`,
headers: { 'x-test-user-id': userId },
payload: { status: 'accepted' },
});
expect(response.statusCode).toBe(200);
const body = JSON.parse(response.body);
expect(body.status).toBe('accepted');
});
it('does not let one user update another user\'s suggestion', async () => {
const patterns = await server.db.select().from(proactivePatterns);
const [victimSuggestion] = await server.db.insert(suggestionsLog).values({
userId: secondUserId,
patternId: patterns[0].id,
context: { owner: 'victim' },
status: 'pending',
}).returning();
const response = await server.inject({
method: 'PATCH',
url: `/api/suggestions/${victimSuggestion.id}`,
headers: { 'x-test-user-id': userId },
payload: { status: 'accepted' },
});
expect(response.statusCode).toBe(404);
expect(response.json()).toEqual({ error: 'Suggestion not found' });
const [unchanged] = await server.db.select().from(suggestionsLog)
.where(eq(suggestionsLog.id, victimSuggestion.id));
expect(unchanged.status).toBe('pending');
expect(unchanged.userId).toBe(secondUserId);
});
it('list pending returns only pending suggestions via API', async () => {
// Clear and create fresh data
await server.db.execute(sql`DELETE FROM suggestions_log WHERE user_id = ${userId}`);
// Create a pending suggestion directly
const patterns = await server.db.select().from(proactivePatterns);
const pattern = patterns[0];
await server.db.insert(suggestionsLog).values([
{ userId, patternId: pattern.id, context: { test: 1 }, status: 'pending' },
{ userId, patternId: pattern.id, context: { test: 2 }, status: 'accepted' },
{ userId, patternId: pattern.id, context: { test: 3 }, status: 'dismissed' },
]);
const response = await server.inject({
method: 'GET',
url: '/api/suggestions',
headers: { 'x-test-user-id': userId },
});
expect(response.statusCode).toBe(200);
const body = JSON.parse(response.body);
expect(Array.isArray(body)).toBe(true);
// Only pending ones should be returned
expect((body as Array<{ status: string }>).every((s) => s.status === 'pending')).toBe(true);
expect(body.length).toBe(1);
});
it('rejects invalid status in PATCH', async () => {
const patterns = await server.db.select().from(proactivePatterns);
const [suggestion] = await server.db.insert(suggestionsLog).values({
userId,
patternId: patterns[0].id,
context: {},
status: 'pending',
}).returning();
const response = await server.inject({
method: 'PATCH',
url: `/api/suggestions/${suggestion.id}`,
headers: { 'x-test-user-id': userId },
payload: { status: 'invalid' },
});
expect(response.statusCode).toBe(400);
});
});

View File

@@ -0,0 +1,581 @@
import { describe, it, expect, beforeAll, afterAll } from 'vitest';
import { buildServer } from '../../src/index.js';
import { users, agents, agentGroups, agentGroupMembers, agentJobs, teams, teamMembers } from '../../src/db/schema.js';
import { sql, eq } from 'drizzle-orm';
describe('Agent API', () => {
let server: Awaited<ReturnType<typeof buildServer>>;
let user1Id: string;
let user2Id: string;
let teamId: string;
let team2Id: string;
let agent1Id: string;
let agent2Id: string;
let foreignAgentId: string;
let group1Id: string;
beforeAll(async () => {
server = await buildServer();
// Clean up leftover test data
await server.db.execute(sql`DELETE FROM agent_group_members WHERE group_id IN (SELECT id FROM agent_groups WHERE user_id IN (SELECT id FROM users WHERE clerk_id LIKE 'agtest_%'))`);
await server.db.execute(sql`DELETE FROM agent_jobs WHERE user_id IN (SELECT id FROM users WHERE clerk_id LIKE 'agtest_%')`);
await server.db.execute(sql`DELETE FROM agent_groups WHERE user_id IN (SELECT id FROM users WHERE clerk_id LIKE 'agtest_%')`);
await server.db.execute(sql`DELETE FROM agents WHERE user_id IN (SELECT id FROM users WHERE clerk_id LIKE 'agtest_%')`);
await server.db.execute(sql`DELETE FROM team_members WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'agtest-%')`);
await server.db.execute(sql`DELETE FROM team_capability_requests WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'agtest-%')`);
await server.db.execute(sql`DELETE FROM team_capability_overrides WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'agtest-%')`);
await server.db.execute(sql`DELETE FROM team_capability_policies WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'agtest-%')`);
await server.db.execute(sql`DELETE FROM teams WHERE slug LIKE 'agtest-%'`);
await server.db.execute(sql`DELETE FROM users WHERE clerk_id LIKE 'agtest_%'`);
// Create test users
const [u1] = await server.db.insert(users).values({
clerkId: 'agtest_user1',
displayName: 'Agent User 1',
email: 'agentuser1@test.com',
}).returning();
user1Id = u1.id;
const [u2] = await server.db.insert(users).values({
clerkId: 'agtest_user2',
displayName: 'Agent User 2',
email: 'agentuser2@test.com',
}).returning();
user2Id = u2.id;
// Create a team for job tests
const [team] = await server.db.insert(teams).values({
name: 'Agent Test Team',
slug: 'agtest-team',
ownerId: user1Id,
}).returning();
teamId = team.id;
await server.db.insert(teamMembers).values({ teamId, userId: user1Id, role: 'owner' });
const [team2] = await server.db.insert(teams).values({
name: 'Agent Test Team 2',
slug: 'agtest-team-2',
ownerId: user2Id,
}).returning();
team2Id = team2.id;
await server.db.insert(teamMembers).values({ teamId: team2Id, userId: user2Id, role: 'owner' });
// Override auth handler for tests
server._authHandler.fn = async function (request, reply) {
const testUserId = request.headers['x-test-user-id'] as string;
if (!testUserId) {
return reply.code(401).send({ error: 'Missing x-test-user-id header' });
}
request.userId = testUserId;
request.clerkId = 'test';
};
});
afterAll(async () => {
await server.db.execute(sql`DELETE FROM agent_group_members WHERE group_id IN (SELECT id FROM agent_groups WHERE user_id IN (SELECT id FROM users WHERE clerk_id LIKE 'agtest_%'))`);
await server.db.execute(sql`DELETE FROM agent_jobs WHERE user_id IN (SELECT id FROM users WHERE clerk_id LIKE 'agtest_%')`);
await server.db.execute(sql`DELETE FROM agent_groups WHERE user_id IN (SELECT id FROM users WHERE clerk_id LIKE 'agtest_%')`);
await server.db.execute(sql`DELETE FROM agents WHERE user_id IN (SELECT id FROM users WHERE clerk_id LIKE 'agtest_%')`);
await server.db.execute(sql`DELETE FROM team_members WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'agtest-%')`);
await server.db.execute(sql`DELETE FROM team_capability_requests WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'agtest-%')`);
await server.db.execute(sql`DELETE FROM team_capability_overrides WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'agtest-%')`);
await server.db.execute(sql`DELETE FROM team_capability_policies WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'agtest-%')`);
await server.db.execute(sql`DELETE FROM teams WHERE slug LIKE 'agtest-%'`);
await server.db.execute(sql`DELETE FROM users WHERE clerk_id LIKE 'agtest_%'`);
await server.close();
});
it('creates an agent with custom model, tools, and system prompt', async () => {
const response = await server.inject({
method: 'POST',
url: '/api/agents',
headers: { 'x-test-user-id': user1Id },
payload: {
name: 'Research Agent',
role: 'researcher',
systemPrompt: 'You are a research agent.',
model: 'claude-sonnet-4-20250514',
tools: ['web_search', 'read_file'],
config: { maxTokens: 4096 },
},
});
expect(response.statusCode).toBe(201);
const body = JSON.parse(response.body);
expect(body.name).toBe('Research Agent');
expect(body.role).toBe('researcher');
expect(body.systemPrompt).toBe('You are a research agent.');
expect(body.model).toBe('claude-sonnet-4-20250514');
expect(body.tools).toEqual(['web_search', 'read_file']);
expect(body.config).toEqual({ maxTokens: 4096 });
expect(body.userId).toBe(user1Id);
agent1Id = body.id;
});
it('creates a second agent for user1', async () => {
const response = await server.inject({
method: 'POST',
url: '/api/agents',
headers: { 'x-test-user-id': user1Id },
payload: {
name: 'Coding Agent',
model: 'claude-haiku-4-5',
tools: ['execute_code'],
},
});
expect(response.statusCode).toBe(201);
agent2Id = JSON.parse(response.body).id;
});
it('lists agents returns only the user\'s agents', async () => {
// Create an agent for user2
const foreignAgentResponse = await server.inject({
method: 'POST',
url: '/api/agents',
headers: { 'x-test-user-id': user2Id },
payload: { name: 'User2 Agent' },
});
expect(foreignAgentResponse.statusCode).toBe(201);
foreignAgentId = JSON.parse(foreignAgentResponse.body).id;
const response = await server.inject({
method: 'GET',
url: '/api/agents',
headers: { 'x-test-user-id': user1Id },
});
expect(response.statusCode).toBe(200);
const body = JSON.parse(response.body);
expect(Array.isArray(body)).toBe(true);
expect(body.length).toBe(2);
expect(body.every((a: { userId: string }) => a.userId === user1Id)).toBe(true);
});
it('updates agent model and config', async () => {
const response = await server.inject({
method: 'PATCH',
url: `/api/agents/${agent1Id}`,
headers: { 'x-test-user-id': user1Id },
payload: {
model: 'claude-haiku-4-5',
config: { maxTokens: 2048, temperature: 0.7 },
},
});
expect(response.statusCode).toBe(200);
const body = JSON.parse(response.body);
expect(body.model).toBe('claude-haiku-4-5');
expect(body.config).toEqual({ maxTokens: 2048, temperature: 0.7 });
});
it('user cannot update another user\'s agent', async () => {
const response = await server.inject({
method: 'PATCH',
url: `/api/agents/${agent1Id}`,
headers: { 'x-test-user-id': user2Id },
payload: { model: 'hacked-model' },
});
expect(response.statusCode).toBe(403);
});
it('user cannot delete another user\'s agent', async () => {
const response = await server.inject({
method: 'DELETE',
url: `/api/agents/${agent1Id}`,
headers: { 'x-test-user-id': user2Id },
});
expect(response.statusCode).toBe(403);
});
it('creates an agent group with parallel strategy and 2 members', async () => {
const response = await server.inject({
method: 'POST',
url: '/api/agent-groups',
headers: { 'x-test-user-id': user1Id },
payload: {
name: 'Research Squad',
description: 'Parallel research team',
strategy: 'parallel',
members: [
{ agentId: agent1Id, roleInGroup: 'worker', executionOrder: 0 },
{ agentId: agent2Id, roleInGroup: 'worker', executionOrder: 0 },
],
},
});
expect(response.statusCode).toBe(201);
const body = JSON.parse(response.body);
expect(body.name).toBe('Research Squad');
expect(body.strategy).toBe('parallel');
expect(body.members).toHaveLength(2);
group1Id = body.id;
});
it('rejects foreign and missing agents identically when creating a group', async () => {
const payload = {
name: 'Cross-tenant group',
strategy: 'parallel',
members: [
{ agentId: agent1Id, roleInGroup: 'worker', executionOrder: 0 },
{ agentId: foreignAgentId, roleInGroup: 'worker', executionOrder: 1 },
],
};
const foreignResponse = await server.inject({
method: 'POST',
url: '/api/agent-groups',
headers: { 'x-test-user-id': user1Id },
payload,
});
const missingResponse = await server.inject({
method: 'POST',
url: '/api/agent-groups',
headers: { 'x-test-user-id': user1Id },
payload: {
...payload,
members: [
payload.members[0],
{ ...payload.members[1], agentId: '00000000-0000-4000-8000-000000000001' },
],
},
});
expect(foreignResponse.statusCode).toBe(404);
expect(missingResponse.statusCode).toBe(404);
expect(JSON.parse(foreignResponse.body)).toEqual({ error: 'Agent not found' });
expect(missingResponse.body).toBe(foreignResponse.body);
const groups = await server.db
.select()
.from(agentGroups)
.where(eq(agentGroups.userId, user1Id));
expect(groups.some((group) => group.name === payload.name)).toBe(false);
});
it('rejects foreign replacement members without altering the owned group', async () => {
const foreignResponse = await server.inject({
method: 'PATCH',
url: `/api/agent-groups/${group1Id}`,
headers: { 'x-test-user-id': user1Id },
payload: {
members: [
{ agentId: agent1Id, roleInGroup: 'worker', executionOrder: 0 },
{ agentId: foreignAgentId, roleInGroup: 'worker', executionOrder: 1 },
],
},
});
const missingResponse = await server.inject({
method: 'PATCH',
url: `/api/agent-groups/${group1Id}`,
headers: { 'x-test-user-id': user1Id },
payload: {
members: [
{ agentId: agent1Id, roleInGroup: 'worker', executionOrder: 0 },
{
agentId: '00000000-0000-4000-8000-000000000001',
roleInGroup: 'worker',
executionOrder: 1,
},
],
},
});
expect(foreignResponse.statusCode).toBe(404);
expect(missingResponse.statusCode).toBe(404);
expect(JSON.parse(foreignResponse.body)).toEqual({ error: 'Agent not found' });
expect(missingResponse.body).toBe(foreignResponse.body);
const groupResponse = await server.inject({
method: 'GET',
url: `/api/agent-groups/${group1Id}`,
headers: { 'x-test-user-id': user1Id },
});
expect(groupResponse.statusCode).toBe(200);
const group = JSON.parse(groupResponse.body);
expect(group.members.map((member: { agentId: string }) => member.agentId).sort())
.toEqual([agent1Id, agent2Id].sort());
});
it('replaces group membership when every agent belongs to the caller', async () => {
const response = await server.inject({
method: 'PATCH',
url: `/api/agent-groups/${group1Id}`,
headers: { 'x-test-user-id': user1Id },
payload: {
members: [
{ agentId: agent1Id, roleInGroup: 'lead', executionOrder: 0 },
{ agentId: agent2Id, roleInGroup: 'worker', executionOrder: 1 },
],
},
});
expect(response.statusCode).toBe(200);
const group = JSON.parse(response.body);
expect(group.members.map((member: { agentId: string }) => member.agentId).sort())
.toEqual([agent1Id, agent2Id].sort());
});
it('creates a group with coordinator strategy and a lead agent', async () => {
const response = await server.inject({
method: 'POST',
url: '/api/agent-groups',
headers: { 'x-test-user-id': user1Id },
payload: {
name: 'Coordinated Team',
strategy: 'coordinator',
members: [
{ agentId: agent1Id, roleInGroup: 'lead', executionOrder: 0 },
{ agentId: agent2Id, roleInGroup: 'worker', executionOrder: 1 },
],
},
});
expect(response.statusCode).toBe(201);
const body = JSON.parse(response.body);
expect(body.strategy).toBe('coordinator');
const lead = body.members.find((m: { roleInGroup: string; agentId: string }) => m.roleInGroup === 'lead');
expect(lead).toBeDefined();
expect(lead.agentId).toBe(agent1Id);
});
it('gets group with members', async () => {
// List groups to get an ID
const listResponse = await server.inject({
method: 'GET',
url: '/api/agent-groups',
headers: { 'x-test-user-id': user1Id },
});
expect(listResponse.statusCode).toBe(200);
const groups = JSON.parse(listResponse.body);
expect(groups.length).toBeGreaterThanOrEqual(2);
const groupId = groups[0].id;
const response = await server.inject({
method: 'GET',
url: `/api/agent-groups/${groupId}`,
headers: { 'x-test-user-id': user1Id },
});
expect(response.statusCode).toBe(200);
const body = JSON.parse(response.body);
expect(body.id).toBe(groupId);
expect(body.members).toBeDefined();
expect(Array.isArray(body.members)).toBe(true);
});
it('executes group run — queues a job and returns 202 with jobId', async () => {
const listResponse = await server.inject({
method: 'GET',
url: '/api/agent-groups',
headers: { 'x-test-user-id': user1Id },
});
const groups = JSON.parse(listResponse.body);
const groupId = groups[0].id;
const response = await server.inject({
method: 'POST',
url: `/api/agent-groups/${groupId}/run`,
headers: { 'x-test-user-id': user1Id },
payload: {
task: 'Research the latest AI papers',
teamId,
},
});
expect(response.statusCode).toBe(202);
const body = JSON.parse(response.body);
expect(body.jobId).toBeDefined();
expect(typeof body.jobId).toBe('string');
// Verify the job was created in the database
const [job] = await server.db
.select()
.from(agentJobs)
.where(eq(agentJobs.id, body.jobId))
.limit(1);
expect(job).toBeDefined();
expect(job.status).toBe('queued');
expect(job.jobType).toBe('group');
expect(job.userId).toBe(user1Id);
});
it('rejects an owned group run attributed to a foreign team', async () => {
const response = await server.inject({
method: 'POST',
url: `/api/agent-groups/${group1Id}/run`,
headers: { 'x-test-user-id': user1Id },
payload: { task: 'Cross-tenant run', teamId: team2Id },
});
expect(response.statusCode).toBe(404);
expect(JSON.parse(response.body)).toEqual({ error: 'Team not found' });
});
it('rejects generic job submission for a foreign team', async () => {
const response = await server.inject({
method: 'POST',
url: '/api/jobs',
headers: { 'x-test-user-id': user1Id },
payload: { jobType: 'chat', teamId: team2Id, input: { message: 'Cross-tenant job' } },
});
expect(response.statusCode).toBe(404);
expect(JSON.parse(response.body)).toEqual({ error: 'Team not found' });
});
it('rejects a generic group job that references another user\'s group', async () => {
const response = await server.inject({
method: 'POST',
url: '/api/jobs',
headers: { 'x-test-user-id': user2Id },
payload: {
jobType: 'group',
teamId: team2Id,
input: { groupId: group1Id, taskInput: { task: 'Run foreign group' } },
},
});
expect(response.statusCode).toBe(404);
expect(JSON.parse(response.body)).toEqual({ error: 'Agent group not found' });
});
it('hides job status from users outside the job team while preserving member access', async () => {
const createResponse = await server.inject({
method: 'POST',
url: '/api/jobs',
headers: { 'x-test-user-id': user1Id },
payload: { jobType: 'chat', teamId, input: { message: 'Private job' } },
});
expect(createResponse.statusCode).toBe(202);
const { jobId } = JSON.parse(createResponse.body);
const foreignResponse = await server.inject({
method: 'GET',
url: `/api/jobs/${jobId}`,
headers: { 'x-test-user-id': user2Id },
});
expect(foreignResponse.statusCode).toBe(404);
expect(JSON.parse(foreignResponse.body)).toEqual({ error: 'Job not found' });
const memberResponse = await server.inject({
method: 'GET',
url: `/api/jobs/${jobId}`,
headers: { 'x-test-user-id': user1Id },
});
expect(memberResponse.statusCode).toBe(200);
expect(JSON.parse(memberResponse.body).id).toBe(jobId);
});
it('prevents users outside the job team from cancelling it', async () => {
const createResponse = await server.inject({
method: 'POST',
url: '/api/jobs',
headers: { 'x-test-user-id': user1Id },
payload: { jobType: 'chat', teamId, input: { message: 'Do not cancel' } },
});
expect(createResponse.statusCode).toBe(202);
const { jobId } = JSON.parse(createResponse.body);
const foreignResponse = await server.inject({
method: 'POST',
url: `/api/jobs/${jobId}/cancel`,
headers: { 'x-test-user-id': user2Id },
});
expect(foreignResponse.statusCode).toBe(404);
expect(JSON.parse(foreignResponse.body)).toEqual({ error: 'Job not found' });
const [unchanged] = await server.db
.select()
.from(agentJobs)
.where(eq(agentJobs.id, jobId))
.limit(1);
expect(unchanged.status).toBe('queued');
const memberResponse = await server.inject({
method: 'POST',
url: `/api/jobs/${jobId}/cancel`,
headers: { 'x-test-user-id': user1Id },
});
expect(memberResponse.statusCode).toBe(200);
});
it('fails closed when a legacy group contains a foreign-owned agent', async () => {
const [legacyGroup] = await server.db.insert(agentGroups).values({
userId: user1Id,
name: 'Legacy compromised group',
strategy: 'parallel',
}).returning();
await server.db.insert(agentGroupMembers).values({
groupId: legacyGroup.id,
agentId: foreignAgentId,
roleInGroup: 'worker',
executionOrder: 0,
});
const getResponse = await server.inject({
method: 'GET',
url: `/api/agent-groups/${legacyGroup.id}`,
headers: { 'x-test-user-id': user1Id },
});
const patchResponse = await server.inject({
method: 'PATCH',
url: `/api/agent-groups/${legacyGroup.id}`,
headers: { 'x-test-user-id': user1Id },
payload: { name: 'Preserved compromise' },
});
const runResponse = await server.inject({
method: 'POST',
url: `/api/agent-groups/${legacyGroup.id}/run`,
headers: { 'x-test-user-id': user1Id },
payload: { task: 'Run foreign configuration', teamId },
});
const jobResponse = await server.inject({
method: 'POST',
url: '/api/jobs',
headers: { 'x-test-user-id': user1Id },
payload: {
jobType: 'group',
teamId,
input: { groupId: legacyGroup.id, taskInput: { task: 'Run foreign configuration' } },
},
});
for (const response of [getResponse, patchResponse, runResponse, jobResponse]) {
expect(response.statusCode).toBe(404);
expect(JSON.parse(response.body)).toEqual({ error: 'Agent group not found' });
}
const [unchanged] = await server.db
.select()
.from(agentGroups)
.where(eq(agentGroups.id, legacyGroup.id))
.limit(1);
expect(unchanged.name).toBe('Legacy compromised group');
});
it('deletes an agent', async () => {
const response = await server.inject({
method: 'DELETE',
url: `/api/agents/${agent2Id}`,
headers: { 'x-test-user-id': user1Id },
});
expect(response.statusCode).toBe(204);
// Verify it's gone
const listResponse = await server.inject({
method: 'GET',
url: '/api/agents',
headers: { 'x-test-user-id': user1Id },
});
const remaining = JSON.parse(listResponse.body);
const ids = remaining.map((a: { id: string }) => a.id);
expect(ids).not.toContain(agent2Id);
});
});

View File

@@ -0,0 +1,261 @@
import { describe, it, expect, beforeAll, afterAll } from 'vitest';
import { buildServer } from '../../src/index.js';
import { users, teams, teamMembers, agentAuditLog, agentJobs, teamCapabilityRequests } from '../../src/db/schema.js';
import { sql } from 'drizzle-orm';
describe('Analytics API', () => {
let server: Awaited<ReturnType<typeof buildServer>>;
let ownerId: string;
let memberId: string;
let teamId: string;
beforeAll(async () => {
server = await buildServer();
// Clean up any leftover test data
await server.db.execute(sql`DELETE FROM agent_audit_log WHERE agent_name = 'analytics-test'`);
await server.db.execute(sql`DELETE FROM agent_jobs WHERE job_type = 'analytics-test'`);
await server.db.execute(sql`DELETE FROM team_capability_requests WHERE justification = 'analytics-test'`);
await server.db.execute(sql`DELETE FROM team_members WHERE team_id IN (SELECT id FROM teams WHERE slug = 'test-analytics')`);
await server.db.execute(sql`DELETE FROM team_capability_policies WHERE team_id IN (SELECT id FROM teams WHERE slug = 'test-analytics')`);
await server.db.execute(sql`DELETE FROM teams WHERE slug = 'test-analytics'`);
await server.db.execute(sql`DELETE FROM users WHERE clerk_id LIKE 'antest_%'`);
// Create test users
const [owner] = await server.db.insert(users).values({
clerkId: 'antest_owner',
displayName: 'Analytics Owner',
email: 'analytics-owner@test.com',
}).returning();
ownerId = owner.id;
const [member] = await server.db.insert(users).values({
clerkId: 'antest_member',
displayName: 'Analytics Member',
email: 'analytics-member@test.com',
}).returning();
memberId = member.id;
// Create team
const [team] = await server.db.insert(teams).values({
name: 'Analytics Test Team',
slug: 'test-analytics',
ownerId,
}).returning();
teamId = team.id;
// Add members
await server.db.insert(teamMembers).values([
{ teamId, userId: ownerId, role: 'owner' },
{ teamId, userId: memberId, role: 'member' },
]);
// Override auth handler for tests
server._authHandler.fn = async function (request, reply) {
const testUserId = request.headers['x-test-user-id'] as string;
if (!testUserId) {
return reply.code(401).send({ error: 'Missing x-test-user-id header' });
}
request.userId = testUserId;
request.clerkId = 'test';
};
});
afterAll(async () => {
await server.db.execute(sql`DELETE FROM agent_audit_log WHERE agent_name = 'analytics-test'`);
await server.db.execute(sql`DELETE FROM agent_jobs WHERE job_type = 'analytics-test'`);
await server.db.execute(sql`DELETE FROM team_capability_requests WHERE justification = 'analytics-test'`);
await server.db.execute(sql`DELETE FROM team_members WHERE team_id IN (SELECT id FROM teams WHERE slug = 'test-analytics')`);
await server.db.execute(sql`DELETE FROM team_capability_policies WHERE team_id IN (SELECT id FROM teams WHERE slug = 'test-analytics')`);
await server.db.execute(sql`DELETE FROM teams WHERE slug = 'test-analytics'`);
await server.db.execute(sql`DELETE FROM users WHERE clerk_id LIKE 'antest_%'`);
await server.close();
});
it('GET /api/admin/teams/:slug/analytics returns correct shape with zeroes for empty data', async () => {
const response = await server.inject({
method: 'GET',
url: '/api/admin/teams/test-analytics/analytics',
headers: { 'x-test-user-id': ownerId },
});
expect(response.statusCode).toBe(200);
const body = JSON.parse(response.body);
// Verify top-level shape
expect(body).toHaveProperty('activeUsers');
expect(body).toHaveProperty('tokenUsage');
expect(body).toHaveProperty('topTools');
expect(body).toHaveProperty('topCommands');
expect(body).toHaveProperty('capabilityGaps');
expect(body).toHaveProperty('performanceTrends');
// activeUsers shape
expect(body.activeUsers).toHaveProperty('daily');
expect(body.activeUsers).toHaveProperty('weekly');
expect(body.activeUsers).toHaveProperty('monthly');
expect(typeof body.activeUsers.daily).toBe('number');
expect(typeof body.activeUsers.weekly).toBe('number');
expect(typeof body.activeUsers.monthly).toBe('number');
// tokenUsage shape
expect(typeof body.tokenUsage.total).toBe('number');
expect(Array.isArray(body.tokenUsage.byUser)).toBe(true);
// topTools and topCommands are arrays
expect(Array.isArray(body.topTools)).toBe(true);
expect(Array.isArray(body.topCommands)).toBe(true);
expect(Array.isArray(body.capabilityGaps)).toBe(true);
// performanceTrends shape
expect(typeof body.performanceTrends.correctionRate).toBe('number');
expect(typeof body.performanceTrends.correctionTrend).toBe('number');
expect(typeof body.performanceTrends.avgResponseTime).toBe('number');
// With no activity, everything should be zeroes
expect(body.activeUsers.daily).toBe(0);
expect(body.activeUsers.weekly).toBe(0);
expect(body.activeUsers.monthly).toBe(0);
expect(body.tokenUsage.total).toBe(0);
expect(body.topTools).toHaveLength(0);
expect(body.topCommands).toHaveLength(0);
expect(body.capabilityGaps).toHaveLength(0);
expect(body.performanceTrends.correctionRate).toBe(0);
expect(body.performanceTrends.avgResponseTime).toBe(0);
});
it('returns 401 without auth header', async () => {
const response = await server.inject({
method: 'GET',
url: '/api/admin/teams/test-analytics/analytics',
});
expect(response.statusCode).toBe(401);
});
it('returns 403 for non-admin member', async () => {
const response = await server.inject({
method: 'GET',
url: '/api/admin/teams/test-analytics/analytics',
headers: { 'x-test-user-id': memberId },
});
expect(response.statusCode).toBe(403);
});
it('returns 404 for non-existent team', async () => {
const response = await server.inject({
method: 'GET',
url: '/api/admin/teams/nonexistent-team/analytics',
headers: { 'x-test-user-id': ownerId },
});
expect(response.statusCode).toBe(404);
});
it('returns data when audit log entries exist', async () => {
// Insert some audit log entries
await server.db.insert(agentAuditLog).values([
{
userId: ownerId,
teamId,
agentName: 'analytics-test',
actionType: 'web_search',
description: 'test search 1',
},
{
userId: ownerId,
teamId,
agentName: 'analytics-test',
actionType: 'web_search',
description: 'test search 2',
},
{
userId: ownerId,
teamId,
agentName: 'analytics-test',
actionType: 'save_memory',
description: 'test memory save',
},
{
userId: ownerId,
teamId,
agentName: 'analytics-test',
actionType: 'command:/research',
description: 'test command',
},
]);
const response = await server.inject({
method: 'GET',
url: '/api/admin/teams/test-analytics/analytics',
headers: { 'x-test-user-id': ownerId },
});
expect(response.statusCode).toBe(200);
const body = JSON.parse(response.body);
// Should detect the active user
expect(body.activeUsers.daily).toBeGreaterThanOrEqual(1);
expect(body.activeUsers.weekly).toBeGreaterThanOrEqual(1);
expect(body.activeUsers.monthly).toBeGreaterThanOrEqual(1);
// Should show top tools
expect(body.topTools.length).toBeGreaterThanOrEqual(1);
const webSearch = body.topTools.find((t: { name: string }) => t.name === 'web_search');
expect(webSearch).toBeDefined();
expect(webSearch.invocations).toBeGreaterThanOrEqual(2);
// Should show top commands
expect(body.topCommands.length).toBeGreaterThanOrEqual(1);
const research = body.topCommands.find((c: { name: string }) => c.name === '/research');
expect(research).toBeDefined();
expect(research.count).toBeGreaterThanOrEqual(1);
});
it('returns capability gaps from pending requests', async () => {
// Insert a pending capability request
await server.db.insert(teamCapabilityRequests).values({
teamId,
requestedBy: memberId,
capabilityName: 'email_send',
capabilityType: 'tool',
justification: 'analytics-test',
status: 'pending',
});
const response = await server.inject({
method: 'GET',
url: '/api/admin/teams/test-analytics/analytics',
headers: { 'x-test-user-id': ownerId },
});
expect(response.statusCode).toBe(200);
const body = JSON.parse(response.body);
expect(body.capabilityGaps.length).toBeGreaterThanOrEqual(1);
const emailGap = body.capabilityGaps.find((g: { tool: string }) => g.tool === 'email_send');
expect(emailGap).toBeDefined();
expect(emailGap.requestCount).toBeGreaterThanOrEqual(1);
expect(emailGap.suggestion).toContain('email_send');
});
it('includes byUser token estimates in tokenUsage', async () => {
const response = await server.inject({
method: 'GET',
url: '/api/admin/teams/test-analytics/analytics',
headers: { 'x-test-user-id': ownerId },
});
expect(response.statusCode).toBe(200);
const body = JSON.parse(response.body);
// byUser should include team members
expect(body.tokenUsage.byUser.length).toBeGreaterThanOrEqual(1);
const ownerEntry = body.tokenUsage.byUser.find((u: { userId: string }) => u.userId === ownerId);
expect(ownerEntry).toBeDefined();
expect(ownerEntry.name).toBe('Analytics Owner');
expect(typeof ownerEntry.tokens).toBe('number');
expect(typeof ownerEntry.cost).toBe('number');
});
});

View File

@@ -0,0 +1,191 @@
import { afterAll, beforeAll, describe, expect, it } from 'vitest';
import { and, eq, sql } from 'drizzle-orm';
import { buildServer } from '../../src/index.js';
import {
messages,
teamCapabilityOverrides,
teamCapabilityRequests,
teamMembers,
teams,
users,
} from '../../src/db/schema.js';
const SLUG_PREFIX = 'cap-bind-';
const MISSING_ID = '00000000-0000-4000-8000-000000000000';
describe('Capability Governance Routes', () => {
let server: Awaited<ReturnType<typeof buildServer>>;
let attackerAdminId: string;
let victimOwnerId: string;
let attackerTeamId: string;
let victimTeamId: string;
beforeAll(async () => {
server = await buildServer();
await server.db.execute(sql`DELETE FROM messages WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE ${SLUG_PREFIX + '%'})`);
await server.db.execute(sql`DELETE FROM team_capability_requests WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE ${SLUG_PREFIX + '%'})`);
await server.db.execute(sql`DELETE FROM team_capability_overrides WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE ${SLUG_PREFIX + '%'})`);
await server.db.execute(sql`DELETE FROM team_capability_policies WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE ${SLUG_PREFIX + '%'})`);
await server.db.execute(sql`DELETE FROM team_members WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE ${SLUG_PREFIX + '%'})`);
await server.db.execute(sql`DELETE FROM teams WHERE slug LIKE ${SLUG_PREFIX + '%'}`);
await server.db.execute(sql`DELETE FROM users WHERE clerk_id LIKE 'cap_bind_%'`);
const [attackerAdmin, victimOwner] = await server.db.insert(users).values([
{
clerkId: 'cap_bind_attacker_admin',
displayName: 'Capability Attacker Admin',
email: 'cap-bind-attacker@test.invalid',
},
{
clerkId: 'cap_bind_victim_owner',
displayName: 'Capability Victim Owner',
email: 'cap-bind-victim@test.invalid',
},
]).returning();
attackerAdminId = attackerAdmin.id;
victimOwnerId = victimOwner.id;
const [attackerTeam, victimTeam] = await server.db.insert(teams).values([
{ name: 'Capability Attacker Team', slug: `${SLUG_PREFIX}attacker`, ownerId: attackerAdminId },
{ name: 'Capability Victim Team', slug: `${SLUG_PREFIX}victim`, ownerId: victimOwnerId },
]).returning();
attackerTeamId = attackerTeam.id;
victimTeamId = victimTeam.id;
await server.db.insert(teamMembers).values([
{ teamId: attackerTeamId, userId: attackerAdminId, role: 'admin' },
{ teamId: victimTeamId, userId: victimOwnerId, role: 'owner' },
]);
server._authHandler.fn = async function (request, reply) {
const testUserId = request.headers['x-test-user-id'] as string;
if (!testUserId) {
return reply.code(401).send({ error: 'Missing x-test-user-id header' });
}
request.userId = testUserId;
request.clerkId = 'test';
};
});
afterAll(async () => {
await server.db.execute(sql`DELETE FROM messages WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE ${SLUG_PREFIX + '%'})`);
await server.db.execute(sql`DELETE FROM team_capability_requests WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE ${SLUG_PREFIX + '%'})`);
await server.db.execute(sql`DELETE FROM team_capability_overrides WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE ${SLUG_PREFIX + '%'})`);
await server.db.execute(sql`DELETE FROM team_capability_policies WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE ${SLUG_PREFIX + '%'})`);
await server.db.execute(sql`DELETE FROM team_members WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE ${SLUG_PREFIX + '%'})`);
await server.db.execute(sql`DELETE FROM teams WHERE slug LIKE ${SLUG_PREFIX + '%'}`);
await server.db.execute(sql`DELETE FROM users WHERE clerk_id LIKE 'cap_bind_%'`);
await server.close();
});
it('does not let an authorized admin delete another team\'s override by ID', async () => {
const [victimOverride] = await server.db.insert(teamCapabilityOverrides).values({
teamId: victimTeamId,
capabilityName: 'victim-secret-tool',
capabilityType: 'mcp',
decision: 'blocked',
decidedBy: victimOwnerId,
}).returning();
const foreign = await server.inject({
method: 'DELETE',
url: `/api/teams/${SLUG_PREFIX}attacker/capability-overrides/${victimOverride.id}`,
headers: { 'x-test-user-id': attackerAdminId },
});
const missing = await server.inject({
method: 'DELETE',
url: `/api/teams/${SLUG_PREFIX}attacker/capability-overrides/${MISSING_ID}`,
headers: { 'x-test-user-id': attackerAdminId },
});
expect({ statusCode: foreign.statusCode, body: foreign.body }).toEqual({
statusCode: missing.statusCode,
body: missing.body,
});
const [stored] = await server.db.select().from(teamCapabilityOverrides).where(and(
eq(teamCapabilityOverrides.id, victimOverride.id),
eq(teamCapabilityOverrides.teamId, victimTeamId),
));
expect(stored).toBeDefined();
});
it('still lets a same-team admin delete an override', async () => {
const [ownOverride] = await server.db.insert(teamCapabilityOverrides).values({
teamId: attackerTeamId,
capabilityName: 'attacker-team-tool',
capabilityType: 'mcp',
decision: 'blocked',
decidedBy: attackerAdminId,
}).returning();
const response = await server.inject({
method: 'DELETE',
url: `/api/teams/${SLUG_PREFIX}attacker/capability-overrides/${ownOverride.id}`,
headers: { 'x-test-user-id': attackerAdminId },
});
expect(response.statusCode).toBe(204);
const [stored] = await server.db.select().from(teamCapabilityOverrides).where(eq(teamCapabilityOverrides.id, ownOverride.id));
expect(stored).toBeUndefined();
});
it('does not let an authorized admin decide another team\'s request by ID', async () => {
const [victimRequest] = await server.db.insert(teamCapabilityRequests).values({
teamId: victimTeamId,
requestedBy: victimOwnerId,
capabilityName: 'victim-requested-tool',
capabilityType: 'mcp',
justification: 'Victim-only request',
}).returning();
const foreign = await server.inject({
method: 'PATCH',
url: `/api/teams/${SLUG_PREFIX}attacker/capability-requests/${victimRequest.id}`,
headers: { 'x-test-user-id': attackerAdminId },
payload: { status: 'rejected', reason: 'cross-team decision attempt' },
});
const missing = await server.inject({
method: 'PATCH',
url: `/api/teams/${SLUG_PREFIX}attacker/capability-requests/${MISSING_ID}`,
headers: { 'x-test-user-id': attackerAdminId },
payload: { status: 'rejected', reason: 'missing request' },
});
expect({ statusCode: foreign.statusCode, body: foreign.body }).toEqual({
statusCode: missing.statusCode,
body: missing.body,
});
const [stored] = await server.db.select().from(teamCapabilityRequests).where(and(
eq(teamCapabilityRequests.id, victimRequest.id),
eq(teamCapabilityRequests.teamId, victimTeamId),
));
expect(stored?.status).toBe('pending');
expect(stored?.decidedBy).toBeNull();
});
it('still lets a same-team admin decide a pending request', async () => {
const [ownRequest] = await server.db.insert(teamCapabilityRequests).values({
teamId: attackerTeamId,
requestedBy: attackerAdminId,
capabilityName: 'attacker-requested-tool',
capabilityType: 'mcp',
justification: 'Same-team request',
}).returning();
const response = await server.inject({
method: 'PATCH',
url: `/api/teams/${SLUG_PREFIX}attacker/capability-requests/${ownRequest.id}`,
headers: { 'x-test-user-id': attackerAdminId },
payload: { status: 'rejected', reason: 'same-team decision' },
});
expect(response.statusCode).toBe(200);
expect(response.json()).toMatchObject({
id: ownRequest.id,
teamId: attackerTeamId,
status: 'rejected',
decidedBy: attackerAdminId,
});
});
});

View File

@@ -0,0 +1,366 @@
import { describe, it, expect, beforeAll, afterAll } from 'vitest';
import { buildServer } from '../../src/index.js';
import { users, teams, teamMembers, teamEntities, teamRelations } from '../../src/db/schema.js';
import { eq, or, sql } from 'drizzle-orm';
describe('Team Knowledge Graph API', () => {
let server: Awaited<ReturnType<typeof buildServer>>;
let ownerId: string;
let memberId: string;
let outsiderId: string;
let teamSlug: string;
let teamId: string;
let foreignEntityId: string;
beforeAll(async () => {
server = await buildServer();
// Clean up any leftover test data
await server.db.execute(sql`DELETE FROM team_relations WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'kgtest-%')`);
await server.db.execute(sql`DELETE FROM team_entities WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'kgtest-%')`);
await server.db.execute(sql`DELETE FROM team_members WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'kgtest-%')`);
await server.db.execute(sql`DELETE FROM team_capability_requests WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'kgtest-%')`);
await server.db.execute(sql`DELETE FROM team_capability_overrides WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'kgtest-%')`);
await server.db.execute(sql`DELETE FROM team_capability_policies WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'kgtest-%')`);
await server.db.execute(sql`DELETE FROM teams WHERE slug LIKE 'kgtest-%'`);
await server.db.execute(sql`DELETE FROM users WHERE clerk_id LIKE 'kgtest_%'`);
// Create test users
const [owner] = await server.db.insert(users).values({
clerkId: 'kgtest_owner',
displayName: 'KG Owner',
email: 'kgtest_owner@test.com',
}).returning();
ownerId = owner.id;
const [member] = await server.db.insert(users).values({
clerkId: 'kgtest_member',
displayName: 'KG Member',
email: 'kgtest_member@test.com',
}).returning();
memberId = member.id;
const [outsider] = await server.db.insert(users).values({
clerkId: 'kgtest_outsider',
displayName: 'KG Outsider',
email: 'kgtest_outsider@test.com',
}).returning();
outsiderId = outsider.id;
// Create a team with owner + member
const [team] = await server.db.insert(teams).values({
name: 'KG Test Team',
slug: 'kgtest-knowledge',
ownerId,
}).returning();
teamId = team.id;
teamSlug = team.slug;
await server.db.insert(teamMembers).values([
{ teamId, userId: ownerId, role: 'owner' },
{ teamId, userId: memberId, role: 'member' },
]);
const [foreignTeam] = await server.db.insert(teams).values({
name: 'Foreign KG Team',
slug: 'kgtest-foreign-knowledge',
ownerId: outsiderId,
}).returning();
await server.db.insert(teamMembers).values({
teamId: foreignTeam.id,
userId: outsiderId,
role: 'owner',
});
const [foreignEntity] = await server.db.insert(teamEntities).values({
teamId: foreignTeam.id,
entityType: 'secret',
name: 'Foreign Entity',
properties: { confidential: true },
sharedBy: outsiderId,
}).returning();
foreignEntityId = foreignEntity.id;
// Override auth handler
server._authHandler.fn = async function (request, reply) {
const testUserId = request.headers['x-test-user-id'] as string;
if (!testUserId) {
return reply.code(401).send({ error: 'Missing x-test-user-id header' });
}
request.userId = testUserId;
request.clerkId = 'test';
};
});
afterAll(async () => {
await server.db.execute(sql`DELETE FROM team_relations WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'kgtest-%')`);
await server.db.execute(sql`DELETE FROM team_entities WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'kgtest-%')`);
await server.db.execute(sql`DELETE FROM team_members WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'kgtest-%')`);
await server.db.execute(sql`DELETE FROM team_capability_requests WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'kgtest-%')`);
await server.db.execute(sql`DELETE FROM team_capability_overrides WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'kgtest-%')`);
await server.db.execute(sql`DELETE FROM team_capability_policies WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'kgtest-%')`);
await server.db.execute(sql`DELETE FROM teams WHERE slug LIKE 'kgtest-%'`);
await server.db.execute(sql`DELETE FROM users WHERE clerk_id LIKE 'kgtest_%'`);
await server.close();
});
it('creates an entity with properties and valid_from/valid_to', async () => {
const response = await server.inject({
method: 'POST',
url: `/api/teams/${teamSlug}/entities`,
headers: { 'x-test-user-id': ownerId },
payload: {
entityType: 'concept',
name: 'Machine Learning',
properties: { domain: 'AI', level: 'advanced' },
validFrom: '2026-01-01T00:00:00.000Z',
validTo: '2027-01-01T00:00:00.000Z',
},
});
expect(response.statusCode).toBe(201);
const body = JSON.parse(response.body);
expect(body.entityType).toBe('concept');
expect(body.name).toBe('Machine Learning');
expect(body.properties).toEqual({ domain: 'AI', level: 'advanced' });
expect(body.sharedBy).toBe(ownerId);
expect(body.teamId).toBe(teamId);
expect(body.validFrom).toBeTruthy();
expect(body.validTo).toBeTruthy();
});
it('searches entities by type', async () => {
// Create entities of different types
await server.inject({
method: 'POST',
url: `/api/teams/${teamSlug}/entities`,
headers: { 'x-test-user-id': ownerId },
payload: { entityType: 'person', name: 'Alice' },
});
await server.inject({
method: 'POST',
url: `/api/teams/${teamSlug}/entities`,
headers: { 'x-test-user-id': ownerId },
payload: { entityType: 'person', name: 'Bob' },
});
const response = await server.inject({
method: 'GET',
url: `/api/teams/${teamSlug}/entities?type=person`,
headers: { 'x-test-user-id': memberId },
});
expect(response.statusCode).toBe(200);
const body = JSON.parse(response.body);
expect(Array.isArray(body)).toBe(true);
expect(body.length).toBeGreaterThanOrEqual(2);
expect(body.every((e: { entityType: string }) => e.entityType === 'person')).toBe(true);
});
it('searches entities by name (ILIKE)', async () => {
const response = await server.inject({
method: 'GET',
url: `/api/teams/${teamSlug}/entities?search=machine`,
headers: { 'x-test-user-id': memberId },
});
expect(response.statusCode).toBe(200);
const body = JSON.parse(response.body);
expect(body.length).toBeGreaterThanOrEqual(1);
expect(body.some((e: { name: string }) => e.name === 'Machine Learning')).toBe(true);
});
it('creates a relation with confidence score', async () => {
// Create two entities to relate
const res1 = await server.inject({
method: 'POST',
url: `/api/teams/${teamSlug}/entities`,
headers: { 'x-test-user-id': ownerId },
payload: { entityType: 'tool', name: 'TensorFlow' },
});
const entity1 = JSON.parse(res1.body);
const res2 = await server.inject({
method: 'POST',
url: `/api/teams/${teamSlug}/entities`,
headers: { 'x-test-user-id': ownerId },
payload: { entityType: 'concept', name: 'Deep Learning' },
});
const entity2 = JSON.parse(res2.body);
const response = await server.inject({
method: 'POST',
url: `/api/teams/${teamSlug}/relations`,
headers: { 'x-test-user-id': ownerId },
payload: {
sourceId: entity1.id,
targetId: entity2.id,
relationType: 'implements',
confidence: 0.95,
properties: { since: '2015' },
},
});
expect(response.statusCode).toBe(201);
const body = JSON.parse(response.body);
expect(body.sourceId).toBe(entity1.id);
expect(body.targetId).toBe(entity2.id);
expect(body.relationType).toBe('implements');
expect(body.confidence).toBeCloseTo(0.95);
expect(body.teamId).toBe(teamId);
});
it('rejects relations when either endpoint belongs to another team', async () => {
const localRes = await server.inject({
method: 'POST',
url: `/api/teams/${teamSlug}/entities`,
headers: { 'x-test-user-id': ownerId },
payload: { entityType: 'concept', name: 'Local Endpoint' },
});
const localEntity = localRes.json();
const foreignSource = await server.inject({
method: 'POST',
url: `/api/teams/${teamSlug}/relations`,
headers: { 'x-test-user-id': ownerId },
payload: {
sourceId: foreignEntityId,
targetId: localEntity.id,
relationType: 'references',
},
});
const foreignTarget = await server.inject({
method: 'POST',
url: `/api/teams/${teamSlug}/relations`,
headers: { 'x-test-user-id': ownerId },
payload: {
sourceId: localEntity.id,
targetId: foreignEntityId,
relationType: 'references',
},
});
expect(foreignSource.statusCode).toBe(404);
expect(foreignSource.json()).toEqual({ error: 'Entity not found' });
expect(foreignTarget.statusCode).toBe(404);
expect(foreignTarget.json()).toEqual({ error: 'Entity not found' });
const leaked = await server.db.select().from(teamRelations).where(or(
eq(teamRelations.sourceId, foreignEntityId),
eq(teamRelations.targetId, foreignEntityId),
));
expect(leaked).toEqual([]);
});
it('graph traversal returns connected entities up to depth N', async () => {
// Create a chain: A -> B -> C
const resA = await server.inject({
method: 'POST',
url: `/api/teams/${teamSlug}/entities`,
headers: { 'x-test-user-id': ownerId },
payload: { entityType: 'node', name: 'Node-A' },
});
const nodeA = JSON.parse(resA.body);
const resB = await server.inject({
method: 'POST',
url: `/api/teams/${teamSlug}/entities`,
headers: { 'x-test-user-id': ownerId },
payload: { entityType: 'node', name: 'Node-B' },
});
const nodeB = JSON.parse(resB.body);
const resC = await server.inject({
method: 'POST',
url: `/api/teams/${teamSlug}/entities`,
headers: { 'x-test-user-id': ownerId },
payload: { entityType: 'node', name: 'Node-C' },
});
const nodeC = JSON.parse(resC.body);
// A -> B
await server.inject({
method: 'POST',
url: `/api/teams/${teamSlug}/relations`,
headers: { 'x-test-user-id': ownerId },
payload: { sourceId: nodeA.id, targetId: nodeB.id, relationType: 'links_to' },
});
// B -> C
await server.inject({
method: 'POST',
url: `/api/teams/${teamSlug}/relations`,
headers: { 'x-test-user-id': ownerId },
payload: { sourceId: nodeB.id, targetId: nodeC.id, relationType: 'links_to' },
});
// Depth 1: should find A and B only
const res1 = await server.inject({
method: 'GET',
url: `/api/teams/${teamSlug}/graph?startId=${nodeA.id}&depth=1`,
headers: { 'x-test-user-id': ownerId },
});
expect(res1.statusCode).toBe(200);
const graph1 = JSON.parse(res1.body);
const entityIds1 = graph1.entities.map((e: { id: string }) => e.id);
expect(entityIds1).toContain(nodeA.id);
expect(entityIds1).toContain(nodeB.id);
expect(entityIds1).not.toContain(nodeC.id);
// Depth 2: should find A, B, and C
const res2 = await server.inject({
method: 'GET',
url: `/api/teams/${teamSlug}/graph?startId=${nodeA.id}&depth=2`,
headers: { 'x-test-user-id': ownerId },
});
expect(res2.statusCode).toBe(200);
const graph2 = JSON.parse(res2.body);
const entityIds2 = graph2.entities.map((e: { id: string }) => e.id);
expect(entityIds2).toContain(nodeA.id);
expect(entityIds2).toContain(nodeB.id);
expect(entityIds2).toContain(nodeC.id);
expect(graph2.relations.length).toBeGreaterThanOrEqual(2);
});
it('does not return a foreign-team graph start entity', async () => {
const response = await server.inject({
method: 'GET',
url: `/api/teams/${teamSlug}/graph?startId=${foreignEntityId}&depth=1`,
headers: { 'x-test-user-id': ownerId },
});
expect(response.statusCode).toBe(404);
expect(response.json()).toEqual({ error: 'Entity not found' });
expect(response.body).not.toContain('Foreign Entity');
expect(response.body).not.toContain('confidential');
});
it('shared_by tracks who contributed', async () => {
// Owner creates entity
const res1 = await server.inject({
method: 'POST',
url: `/api/teams/${teamSlug}/entities`,
headers: { 'x-test-user-id': ownerId },
payload: { entityType: 'doc', name: 'Owner Doc' },
});
expect(JSON.parse(res1.body).sharedBy).toBe(ownerId);
// Member creates entity
const res2 = await server.inject({
method: 'POST',
url: `/api/teams/${teamSlug}/entities`,
headers: { 'x-test-user-id': memberId },
payload: { entityType: 'doc', name: 'Member Doc' },
});
expect(JSON.parse(res2.body).sharedBy).toBe(memberId);
});
it('non-member gets 403', async () => {
const response = await server.inject({
method: 'GET',
url: `/api/teams/${teamSlug}/entities`,
headers: { 'x-test-user-id': outsiderId },
});
expect(response.statusCode).toBe(403);
});
});

View File

@@ -0,0 +1,392 @@
import { describe, it, expect, beforeAll, afterAll } from 'vitest';
import { buildServer } from '../../src/index.js';
import { users, teams, teamMembers, teamEntities, tasks, messages } from '../../src/db/schema.js';
import { sql } from 'drizzle-orm';
describe('Waggle Dance Messages API', () => {
let server: Awaited<ReturnType<typeof buildServer>>;
let ownerId: string;
let memberId: string;
let outsiderId: string;
let teamSlug: string;
let teamId: string;
const SLUG_PREFIX = 'msgtest-';
beforeAll(async () => {
server = await buildServer();
// Clean up any leftover test data (order matters for FK constraints)
await server.db.execute(sql`DELETE FROM messages WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE ${SLUG_PREFIX + '%'})`);
await server.db.execute(sql`DELETE FROM team_entities WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE ${SLUG_PREFIX + '%'})`);
await server.db.execute(sql`DELETE FROM tasks WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE ${SLUG_PREFIX + '%'})`);
await server.db.execute(sql`DELETE FROM team_members WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE ${SLUG_PREFIX + '%'})`);
await server.db.execute(sql`DELETE FROM team_capability_requests WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE ${SLUG_PREFIX + '%'})`);
await server.db.execute(sql`DELETE FROM team_capability_overrides WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE ${SLUG_PREFIX + '%'})`);
await server.db.execute(sql`DELETE FROM team_capability_policies WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE ${SLUG_PREFIX + '%'})`);
await server.db.execute(sql`DELETE FROM teams WHERE slug LIKE ${SLUG_PREFIX + '%'}`);
await server.db.execute(sql`DELETE FROM users WHERE clerk_id LIKE 'msgtest_%'`);
// Create test users
const [owner] = await server.db.insert(users).values({
clerkId: 'msgtest_owner',
displayName: 'Msg Owner',
email: 'msgtest_owner@test.com',
}).returning();
ownerId = owner.id;
const [member] = await server.db.insert(users).values({
clerkId: 'msgtest_member',
displayName: 'Msg Member',
email: 'msgtest_member@test.com',
}).returning();
memberId = member.id;
const [outsider] = await server.db.insert(users).values({
clerkId: 'msgtest_outsider',
displayName: 'Msg Outsider',
email: 'msgtest_outsider@test.com',
}).returning();
outsiderId = outsider.id;
// Create a team with owner + member
const [team] = await server.db.insert(teams).values({
name: 'Msg Test Team',
slug: `${SLUG_PREFIX}waggle`,
ownerId,
}).returning();
teamId = team.id;
teamSlug = team.slug;
await server.db.insert(teamMembers).values([
{ teamId, userId: ownerId, role: 'owner' },
{ teamId, userId: memberId, role: 'member' },
]);
// Seed some team_entities and tasks for hive-check tests
await server.db.insert(teamEntities).values([
{ teamId, entityType: 'concept', name: 'Machine Learning', properties: { domain: 'AI' }, sharedBy: ownerId },
{ teamId, entityType: 'tool', name: 'TensorFlow', properties: { lang: 'python' }, sharedBy: memberId },
{ teamId, entityType: 'concept', name: 'Database Design', properties: { domain: 'engineering' }, sharedBy: ownerId },
]);
await server.db.insert(tasks).values([
{ teamId, title: 'Implement ML pipeline', description: 'Build a machine learning pipeline', status: 'open', createdBy: ownerId },
{ teamId, title: 'Fix login bug', description: 'Login page crashes on mobile', status: 'done', createdBy: memberId },
]);
// Override auth handler
server._authHandler.fn = async function (request, reply) {
const testUserId = request.headers['x-test-user-id'] as string;
if (!testUserId) {
return reply.code(401).send({ error: 'Missing x-test-user-id header' });
}
request.userId = testUserId;
request.clerkId = 'test';
};
});
afterAll(async () => {
await server.db.execute(sql`DELETE FROM messages WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE ${SLUG_PREFIX + '%'})`);
await server.db.execute(sql`DELETE FROM team_entities WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE ${SLUG_PREFIX + '%'})`);
await server.db.execute(sql`DELETE FROM tasks WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE ${SLUG_PREFIX + '%'})`);
await server.db.execute(sql`DELETE FROM team_members WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE ${SLUG_PREFIX + '%'})`);
await server.db.execute(sql`DELETE FROM team_capability_requests WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE ${SLUG_PREFIX + '%'})`);
await server.db.execute(sql`DELETE FROM team_capability_overrides WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE ${SLUG_PREFIX + '%'})`);
await server.db.execute(sql`DELETE FROM team_capability_policies WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE ${SLUG_PREFIX + '%'})`);
await server.db.execute(sql`DELETE FROM teams WHERE slug LIKE ${SLUG_PREFIX + '%'}`);
await server.db.execute(sql`DELETE FROM users WHERE clerk_id LIKE 'msgtest_%'`);
await server.close();
});
it('sends a broadcast message and returns 201', async () => {
const response = await server.inject({
method: 'POST',
url: `/api/teams/${teamSlug}/messages`,
headers: { 'x-test-user-id': ownerId },
payload: {
type: 'broadcast',
subtype: 'discovery',
content: { topic: 'New skill available', details: 'web-scraper v2' },
},
});
expect(response.statusCode).toBe(201);
const body = JSON.parse(response.body);
expect(body.type).toBe('broadcast');
expect(body.subtype).toBe('discovery');
expect(body.content).toEqual({ topic: 'New skill available', details: 'web-scraper v2' });
expect(body.senderId).toBe(ownerId);
expect(body.teamId).toBe(teamId);
expect(body.id).toBeDefined();
});
it('sends a request message with valid type-subtype combo', async () => {
const response = await server.inject({
method: 'POST',
url: `/api/teams/${teamSlug}/messages`,
headers: { 'x-test-user-id': memberId },
payload: {
type: 'request',
subtype: 'knowledge_check',
content: { query: 'Who knows about React?' },
},
});
expect(response.statusCode).toBe(201);
const body = JSON.parse(response.body);
expect(body.type).toBe('request');
expect(body.subtype).toBe('knowledge_check');
});
it('rejects invalid type-subtype combination with 400', async () => {
const response = await server.inject({
method: 'POST',
url: `/api/teams/${teamSlug}/messages`,
headers: { 'x-test-user-id': ownerId },
payload: {
type: 'request',
subtype: 'discovery', // discovery is a broadcast subtype, not request
content: { query: 'test' },
},
});
expect(response.statusCode).toBe(400);
const body = JSON.parse(response.body);
expect(body.error).toContain('Invalid type-subtype combination');
});
it('stores routing field when provided', async () => {
const routing = [
{ userId: memberId, reason: 'Expert in ML' },
];
const response = await server.inject({
method: 'POST',
url: `/api/teams/${teamSlug}/messages`,
headers: { 'x-test-user-id': ownerId },
payload: {
type: 'broadcast',
subtype: 'routed_share',
content: { data: 'ML model results' },
routing,
},
});
expect(response.statusCode).toBe(201);
const body = JSON.parse(response.body);
expect(body.routing).toEqual(routing);
});
it('stores referenceId when provided', async () => {
// First create a message to reference
const firstRes = await server.inject({
method: 'POST',
url: `/api/teams/${teamSlug}/messages`,
headers: { 'x-test-user-id': memberId },
payload: {
type: 'request',
subtype: 'task_delegation',
content: { task: 'Review PR #42' },
},
});
const firstMsg = JSON.parse(firstRes.body);
// Send a response referencing the first message
const response = await server.inject({
method: 'POST',
url: `/api/teams/${teamSlug}/messages`,
headers: { 'x-test-user-id': ownerId },
payload: {
type: 'response',
subtype: 'task_claim',
content: { accepted: true },
referenceId: firstMsg.id,
},
});
expect(response.statusCode).toBe(201);
const body = JSON.parse(response.body);
expect(body.referenceId).toBe(firstMsg.id);
});
it('lists messages for the team', async () => {
const response = await server.inject({
method: 'GET',
url: `/api/teams/${teamSlug}/messages`,
headers: { 'x-test-user-id': memberId },
});
expect(response.statusCode).toBe(200);
const body = JSON.parse(response.body);
expect(Array.isArray(body)).toBe(true);
expect(body.length).toBeGreaterThanOrEqual(1);
});
it('filters messages by type', async () => {
const response = await server.inject({
method: 'GET',
url: `/api/teams/${teamSlug}/messages?type=broadcast`,
headers: { 'x-test-user-id': memberId },
});
expect(response.statusCode).toBe(200);
const body = JSON.parse(response.body);
expect(Array.isArray(body)).toBe(true);
expect(body.every((m: { type: string }) => m.type === 'broadcast')).toBe(true);
expect(body.length).toBeGreaterThanOrEqual(1);
});
it('filters messages by subtype', async () => {
const response = await server.inject({
method: 'GET',
url: `/api/teams/${teamSlug}/messages?subtype=discovery`,
headers: { 'x-test-user-id': memberId },
});
expect(response.statusCode).toBe(200);
const body = JSON.parse(response.body);
expect(Array.isArray(body)).toBe(true);
expect(body.every((m: { subtype: string }) => m.subtype === 'discovery')).toBe(true);
});
it('publishes message to Redis channel on send', async () => {
// Subscribe to the team channel before sending
const receivedMessages: string[] = [];
await server.redisSub.subscribe(`team:${teamId}:waggle`);
server.redisSub.on('message', (_channel: string, message: string) => {
receivedMessages.push(message);
});
const response = await server.inject({
method: 'POST',
url: `/api/teams/${teamSlug}/messages`,
headers: { 'x-test-user-id': ownerId },
payload: {
type: 'broadcast',
subtype: 'skill_share',
content: { skill: 'data-analysis', version: '1.0' },
},
});
expect(response.statusCode).toBe(201);
// Give Redis a moment to deliver
await new Promise((resolve) => setTimeout(resolve, 200));
expect(receivedMessages.length).toBeGreaterThanOrEqual(1);
const published = JSON.parse(receivedMessages[receivedMessages.length - 1]);
expect(published.subtype).toBe('skill_share');
expect(published.content).toEqual({ skill: 'data-analysis', version: '1.0' });
// Cleanup subscription
await server.redisSub.unsubscribe(`team:${teamId}:waggle`);
server.redisSub.removeAllListeners('message');
});
it('non-member gets 403 when sending messages', async () => {
const response = await server.inject({
method: 'POST',
url: `/api/teams/${teamSlug}/messages`,
headers: { 'x-test-user-id': outsiderId },
payload: {
type: 'broadcast',
subtype: 'discovery',
content: { test: true },
},
});
expect(response.statusCode).toBe(403);
});
it('non-member gets 403 when listing messages', async () => {
const response = await server.inject({
method: 'GET',
url: `/api/teams/${teamSlug}/messages`,
headers: { 'x-test-user-id': outsiderId },
});
expect(response.statusCode).toBe(403);
});
describe('hive-check', () => {
it('finds matching entities by topic', async () => {
const response = await server.inject({
method: 'POST',
url: `/api/teams/${teamSlug}/messages/hive-check`,
headers: { 'x-test-user-id': ownerId },
payload: { topic: 'Machine Learning' },
});
expect(response.statusCode).toBe(200);
const body = JSON.parse(response.body);
expect(body.entities.length).toBeGreaterThanOrEqual(1);
expect(body.entities.some((e: { name: string }) => e.name === 'Machine Learning')).toBe(true);
});
it('finds matching tasks by topic', async () => {
const response = await server.inject({
method: 'POST',
url: `/api/teams/${teamSlug}/messages/hive-check`,
headers: { 'x-test-user-id': memberId },
payload: { topic: 'ML pipeline' },
});
expect(response.statusCode).toBe(200);
const body = JSON.parse(response.body);
expect(body.relatedTasks.length).toBeGreaterThanOrEqual(1);
expect(body.relatedTasks.some((t: { title: string }) => t.title.includes('ML pipeline'))).toBe(true);
});
it('finds matching broadcast messages', async () => {
// We already sent broadcast messages earlier in the test suite
const response = await server.inject({
method: 'POST',
url: `/api/teams/${teamSlug}/messages/hive-check`,
headers: { 'x-test-user-id': ownerId },
payload: { topic: 'anything' },
});
expect(response.statusCode).toBe(200);
const body = JSON.parse(response.body);
expect(body.relatedMessages).toBeDefined();
expect(Array.isArray(body.relatedMessages)).toBe(true);
});
it('returns empty results for non-matching topic', async () => {
const response = await server.inject({
method: 'POST',
url: `/api/teams/${teamSlug}/messages/hive-check`,
headers: { 'x-test-user-id': ownerId },
payload: { topic: 'xyzzy_nonexistent_topic_12345' },
});
expect(response.statusCode).toBe(200);
const body = JSON.parse(response.body);
expect(body.entities).toHaveLength(0);
expect(body.relatedTasks).toHaveLength(0);
});
it('non-member gets 403 on hive-check', async () => {
const response = await server.inject({
method: 'POST',
url: `/api/teams/${teamSlug}/messages/hive-check`,
headers: { 'x-test-user-id': outsiderId },
payload: { topic: 'test' },
});
expect(response.statusCode).toBe(403);
});
it('validates hive-check input', async () => {
const response = await server.inject({
method: 'POST',
url: `/api/teams/${teamSlug}/messages/hive-check`,
headers: { 'x-test-user-id': ownerId },
payload: {}, // missing topic
});
expect(response.statusCode).toBe(400);
});
});
});

View File

@@ -0,0 +1,263 @@
import { describe, it, expect, beforeAll, afterAll } from 'vitest';
import { buildServer } from '../../src/index.js';
import { users, teams, teamMembers, teamResources } from '../../src/db/schema.js';
import { eq, sql } from 'drizzle-orm';
describe('Team Resources API', () => {
let server: Awaited<ReturnType<typeof buildServer>>;
let ownerId: string;
let memberId: string;
let outsiderId: string;
let teamSlug: string;
let teamId: string;
beforeAll(async () => {
server = await buildServer();
// Clean up any leftover test data
await server.db.execute(sql`DELETE FROM team_resources WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'restest-%')`);
await server.db.execute(sql`DELETE FROM team_members WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'restest-%')`);
await server.db.execute(sql`DELETE FROM team_capability_requests WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'restest-%')`);
await server.db.execute(sql`DELETE FROM team_capability_overrides WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'restest-%')`);
await server.db.execute(sql`DELETE FROM team_capability_policies WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'restest-%')`);
await server.db.execute(sql`DELETE FROM teams WHERE slug LIKE 'restest-%'`);
await server.db.execute(sql`DELETE FROM users WHERE clerk_id LIKE 'restest_%'`);
// Create test users
const [owner] = await server.db.insert(users).values({
clerkId: 'restest_owner',
displayName: 'Res Owner',
email: 'restest_owner@test.com',
}).returning();
ownerId = owner.id;
const [member] = await server.db.insert(users).values({
clerkId: 'restest_member',
displayName: 'Res Member',
email: 'restest_member@test.com',
}).returning();
memberId = member.id;
const [outsider] = await server.db.insert(users).values({
clerkId: 'restest_outsider',
displayName: 'Res Outsider',
email: 'restest_outsider@test.com',
}).returning();
outsiderId = outsider.id;
// Create a team with owner + member
const [team] = await server.db.insert(teams).values({
name: 'Res Test Team',
slug: 'restest-resources',
ownerId,
}).returning();
teamId = team.id;
teamSlug = team.slug;
await server.db.insert(teamMembers).values([
{ teamId, userId: ownerId, role: 'owner' },
{ teamId, userId: memberId, role: 'member' },
]);
// Override auth handler
server._authHandler.fn = async function (request, reply) {
const testUserId = request.headers['x-test-user-id'] as string;
if (!testUserId) {
return reply.code(401).send({ error: 'Missing x-test-user-id header' });
}
request.userId = testUserId;
request.clerkId = 'test';
};
});
afterAll(async () => {
await server.db.execute(sql`DELETE FROM team_resources WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'restest-%')`);
await server.db.execute(sql`DELETE FROM team_members WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'restest-%')`);
await server.db.execute(sql`DELETE FROM team_capability_requests WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'restest-%')`);
await server.db.execute(sql`DELETE FROM team_capability_overrides WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'restest-%')`);
await server.db.execute(sql`DELETE FROM team_capability_policies WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'restest-%')`);
await server.db.execute(sql`DELETE FROM teams WHERE slug LIKE 'restest-%'`);
await server.db.execute(sql`DELETE FROM users WHERE clerk_id LIKE 'restest_%'`);
await server.close();
});
it('shares a model_recipe resource', async () => {
const response = await server.inject({
method: 'POST',
url: `/api/teams/${teamSlug}/resources`,
headers: { 'x-test-user-id': ownerId },
payload: {
resourceType: 'model_recipe',
name: 'GPT-4 Coding Recipe',
description: 'Optimized for code generation',
config: { model: 'gpt-4', temperature: 0.2 },
},
});
expect(response.statusCode).toBe(201);
const body = JSON.parse(response.body);
expect(body.resourceType).toBe('model_recipe');
expect(body.name).toBe('GPT-4 Coding Recipe');
expect(body.description).toBe('Optimized for code generation');
expect(body.config).toEqual({ model: 'gpt-4', temperature: 0.2 });
expect(body.sharedBy).toBe(ownerId);
expect(body.rating).toBe(0);
expect(body.useCount).toBe(0);
});
it('shares a skill resource', async () => {
const response = await server.inject({
method: 'POST',
url: `/api/teams/${teamSlug}/resources`,
headers: { 'x-test-user-id': memberId },
payload: {
resourceType: 'skill',
name: 'Code Review Skill',
description: 'Automated code review with best practices',
config: { language: 'typescript', rules: ['no-any', 'strict-null'] },
},
});
expect(response.statusCode).toBe(201);
const body = JSON.parse(response.body);
expect(body.resourceType).toBe('skill');
expect(body.name).toBe('Code Review Skill');
expect(body.sharedBy).toBe(memberId);
});
it('rates a resource and updates running average', async () => {
// Create a resource first
const createRes = await server.inject({
method: 'POST',
url: `/api/teams/${teamSlug}/resources`,
headers: { 'x-test-user-id': ownerId },
payload: {
resourceType: 'prompt_template',
name: 'Summarizer Prompt',
config: { template: 'Summarize: {{input}}' },
},
});
const resource = JSON.parse(createRes.body);
// First rating: should be the rating itself (useCount was 0)
const rate1 = await server.inject({
method: 'PATCH',
url: `/api/teams/${teamSlug}/resources/${resource.id}`,
headers: { 'x-test-user-id': ownerId },
payload: { rating: 4 },
});
expect(rate1.statusCode).toBe(200);
const body1 = JSON.parse(rate1.body);
// After first rate: rating was set to 4 (useCount was 0), then useCount incremented to 1
expect(body1.useCount).toBe(1);
// Second rating: running average = (4 * 1 + 2) / 2 = 3
const rate2 = await server.inject({
method: 'PATCH',
url: `/api/teams/${teamSlug}/resources/${resource.id}`,
headers: { 'x-test-user-id': memberId },
payload: { rating: 2 },
});
expect(rate2.statusCode).toBe(200);
const body2 = JSON.parse(rate2.body);
expect(body2.useCount).toBe(2);
// rating = (4 * 1 + 2) / 2 = 3
expect(body2.rating).toBeCloseTo(3, 1);
});
it('increments use_count on rate', async () => {
const createRes = await server.inject({
method: 'POST',
url: `/api/teams/${teamSlug}/resources`,
headers: { 'x-test-user-id': ownerId },
payload: {
resourceType: 'tool_config',
name: 'Linter Config',
config: { tool: 'eslint', extends: 'recommended' },
},
});
const resource = JSON.parse(createRes.body);
expect(resource.useCount).toBe(0);
// Rate it
const rateRes = await server.inject({
method: 'PATCH',
url: `/api/teams/${teamSlug}/resources/${resource.id}`,
headers: { 'x-test-user-id': memberId },
payload: { rating: 5 },
});
const rated = JSON.parse(rateRes.body);
expect(rated.useCount).toBe(1);
// Rate again
const rateRes2 = await server.inject({
method: 'PATCH',
url: `/api/teams/${teamSlug}/resources/${resource.id}`,
headers: { 'x-test-user-id': ownerId },
payload: { rating: 3 },
});
const rated2 = JSON.parse(rateRes2.body);
expect(rated2.useCount).toBe(2);
});
it('does not rate a resource owned by another team through this team route', async () => {
const [foreignTeam] = await server.db.insert(teams).values({
name: 'Foreign Resource Team',
slug: 'restest-foreign-resources',
ownerId: outsiderId,
}).returning();
await server.db.insert(teamMembers).values({
teamId: foreignTeam.id,
userId: outsiderId,
role: 'owner',
});
const [foreignResource] = await server.db.insert(teamResources).values({
teamId: foreignTeam.id,
resourceType: 'model_recipe',
name: 'Foreign Recipe',
config: { model: 'private-model' },
sharedBy: outsiderId,
rating: 1,
useCount: 1,
}).returning();
const response = await server.inject({
method: 'PATCH',
url: `/api/teams/${teamSlug}/resources/${foreignResource.id}`,
headers: { 'x-test-user-id': ownerId },
payload: { rating: 5 },
});
expect(response.statusCode).toBe(404);
expect(response.json()).toEqual({ error: 'Resource not found' });
const [unchanged] = await server.db.select().from(teamResources)
.where(eq(teamResources.id, foreignResource.id));
expect(unchanged.rating).toBe(1);
expect(unchanged.useCount).toBe(1);
});
it('filters resources by resource_type', async () => {
const response = await server.inject({
method: 'GET',
url: `/api/teams/${teamSlug}/resources?type=skill`,
headers: { 'x-test-user-id': ownerId },
});
expect(response.statusCode).toBe(200);
const body = JSON.parse(response.body);
expect(Array.isArray(body)).toBe(true);
expect(body.length).toBeGreaterThanOrEqual(1);
expect(body.every((r: { resourceType: string }) => r.resourceType === 'skill')).toBe(true);
});
it('non-member gets 403', async () => {
const response = await server.inject({
method: 'GET',
url: `/api/teams/${teamSlug}/resources`,
headers: { 'x-test-user-id': outsiderId },
});
expect(response.statusCode).toBe(403);
});
});

View File

@@ -0,0 +1,210 @@
import { describe, it, expect, beforeAll, afterAll } from 'vitest';
import { buildServer } from '../../src/index.js';
import { users, teams, teamMembers, tasks } from '../../src/db/schema.js';
import { sql } from 'drizzle-orm';
describe('Task Board API', () => {
let server: Awaited<ReturnType<typeof buildServer>>;
let ownerId: string;
let memberId: string;
let outsiderId: string;
let teamSlug: string;
let teamId: string;
let createdTaskId: string;
beforeAll(async () => {
server = await buildServer();
// Clean up any leftover test data
await server.db.execute(sql`DELETE FROM tasks WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'tstest-%')`);
await server.db.execute(sql`DELETE FROM team_members WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'tstest-%')`);
await server.db.execute(sql`DELETE FROM team_capability_requests WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'tstest-%')`);
await server.db.execute(sql`DELETE FROM team_capability_overrides WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'tstest-%')`);
await server.db.execute(sql`DELETE FROM team_capability_policies WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'tstest-%')`);
await server.db.execute(sql`DELETE FROM teams WHERE slug LIKE 'tstest-%'`);
await server.db.execute(sql`DELETE FROM users WHERE clerk_id LIKE 'tstest_%'`);
// Create test users
const [owner] = await server.db.insert(users).values({
clerkId: 'tstest_owner',
displayName: 'Task Owner',
email: 'tstest_owner@test.com',
}).returning();
ownerId = owner.id;
const [member] = await server.db.insert(users).values({
clerkId: 'tstest_member',
displayName: 'Task Member',
email: 'tstest_member@test.com',
}).returning();
memberId = member.id;
const [outsider] = await server.db.insert(users).values({
clerkId: 'tstest_outsider',
displayName: 'Task Outsider',
email: 'tstest_outsider@test.com',
}).returning();
outsiderId = outsider.id;
// Create a team with owner + member
const [team] = await server.db.insert(teams).values({
name: 'Task Test Team',
slug: 'tstest-tasks',
ownerId,
}).returning();
teamId = team.id;
teamSlug = team.slug;
await server.db.insert(teamMembers).values([
{ teamId, userId: ownerId, role: 'owner' },
{ teamId, userId: memberId, role: 'member' },
]);
// Override auth handler
server._authHandler.fn = async function (request, reply) {
const testUserId = request.headers['x-test-user-id'] as string;
if (!testUserId) {
return reply.code(401).send({ error: 'Missing x-test-user-id header' });
}
request.userId = testUserId;
request.clerkId = 'test';
};
});
afterAll(async () => {
await server.db.execute(sql`DELETE FROM tasks WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'tstest-%')`);
await server.db.execute(sql`DELETE FROM team_members WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'tstest-%')`);
await server.db.execute(sql`DELETE FROM team_capability_requests WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'tstest-%')`);
await server.db.execute(sql`DELETE FROM team_capability_overrides WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'tstest-%')`);
await server.db.execute(sql`DELETE FROM team_capability_policies WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'tstest-%')`);
await server.db.execute(sql`DELETE FROM teams WHERE slug LIKE 'tstest-%'`);
await server.db.execute(sql`DELETE FROM users WHERE clerk_id LIKE 'tstest_%'`);
await server.close();
});
it('creates a task on team board', async () => {
const response = await server.inject({
method: 'POST',
url: `/api/teams/${teamSlug}/tasks`,
headers: { 'x-test-user-id': ownerId },
payload: { title: 'Research competitors', description: 'Analyze top 5 competitors', priority: 'high' },
});
expect(response.statusCode).toBe(201);
const body = JSON.parse(response.body);
expect(body.title).toBe('Research competitors');
expect(body.description).toBe('Analyze top 5 competitors');
expect(body.priority).toBe('high');
expect(body.status).toBe('open');
expect(body.createdBy).toBe(ownerId);
expect(body.teamId).toBe(teamId);
createdTaskId = body.id;
});
it('lists tasks on team board', async () => {
const response = await server.inject({
method: 'GET',
url: `/api/teams/${teamSlug}/tasks`,
headers: { 'x-test-user-id': memberId },
});
expect(response.statusCode).toBe(200);
const body = JSON.parse(response.body);
expect(Array.isArray(body)).toBe(true);
expect(body.length).toBeGreaterThanOrEqual(1);
expect(body.some((t: { id: string }) => t.id === createdTaskId)).toBe(true);
});
it('lists tasks with status filter', async () => {
// Create a second task and mark it done
const createRes = await server.inject({
method: 'POST',
url: `/api/teams/${teamSlug}/tasks`,
headers: { 'x-test-user-id': ownerId },
payload: { title: 'Done task' },
});
const doneTask = JSON.parse(createRes.body);
await server.inject({
method: 'PATCH',
url: `/api/teams/${teamSlug}/tasks/${doneTask.id}`,
headers: { 'x-test-user-id': ownerId },
payload: { status: 'done' },
});
// Filter by status=open
const response = await server.inject({
method: 'GET',
url: `/api/teams/${teamSlug}/tasks?status=open`,
headers: { 'x-test-user-id': memberId },
});
expect(response.statusCode).toBe(200);
const body = JSON.parse(response.body);
expect(body.every((t: { status: string }) => t.status === 'open')).toBe(true);
expect(body.some((t: { id: string }) => t.id === doneTask.id)).toBe(false);
});
it('claims a task — sets assignedTo and status to claimed', async () => {
const response = await server.inject({
method: 'POST',
url: `/api/teams/${teamSlug}/tasks/${createdTaskId}/claim`,
headers: { 'x-test-user-id': memberId },
});
expect(response.statusCode).toBe(200);
const body = JSON.parse(response.body);
expect(body.assignedTo).toBe(memberId);
expect(body.status).toBe('claimed');
});
it('completes a task — status changes to done', async () => {
const response = await server.inject({
method: 'PATCH',
url: `/api/teams/${teamSlug}/tasks/${createdTaskId}`,
headers: { 'x-test-user-id': memberId },
payload: { status: 'done' },
});
expect(response.statusCode).toBe(200);
const body = JSON.parse(response.body);
expect(body.status).toBe('done');
});
it('creates a subtask with parentTaskId', async () => {
const response = await server.inject({
method: 'POST',
url: `/api/teams/${teamSlug}/tasks`,
headers: { 'x-test-user-id': ownerId },
payload: { title: 'Sub-research item', parentTaskId: createdTaskId },
});
expect(response.statusCode).toBe(201);
const body = JSON.parse(response.body);
expect(body.parentTaskId).toBe(createdTaskId);
expect(body.priority).toBe('normal');
});
it('non-team-member gets 403', async () => {
const response = await server.inject({
method: 'GET',
url: `/api/teams/${teamSlug}/tasks`,
headers: { 'x-test-user-id': outsiderId },
});
expect(response.statusCode).toBe(403);
});
it('gets a single task by id', async () => {
const response = await server.inject({
method: 'GET',
url: `/api/teams/${teamSlug}/tasks/${createdTaskId}`,
headers: { 'x-test-user-id': ownerId },
});
expect(response.statusCode).toBe(200);
const body = JSON.parse(response.body);
expect(body.id).toBe(createdTaskId);
expect(body.title).toBe('Research competitors');
});
});

View File

@@ -0,0 +1,304 @@
import { describe, it, expect, beforeAll, afterAll } from 'vitest';
import { buildServer } from '../../src/index.js';
import { users, teams, teamMembers } from '../../src/db/schema.js';
import { sql } from 'drizzle-orm';
describe('Team API', () => {
let server: Awaited<ReturnType<typeof buildServer>>;
let ownerId: string;
let memberId: string;
let adminId: string;
beforeAll(async () => {
server = await buildServer();
// Clean up any leftover test data (use unique prefix to avoid collision with auth tests)
// Narrow to 'test-team%' — previously 'test-%' collided with analytics.test.ts's
// 'test-analytics' slug when files ran in parallel and wiped it mid-run, causing
// spurious 403s because the analytics team's owner was no longer a member.
await server.db.execute(sql`DELETE FROM team_members WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'test-team%')`);
await server.db.execute(sql`DELETE FROM team_capability_requests WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'test-team%')`);
await server.db.execute(sql`DELETE FROM team_capability_overrides WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'test-team%')`);
await server.db.execute(sql`DELETE FROM team_capability_policies WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'test-team%')`);
await server.db.execute(sql`DELETE FROM teams WHERE slug LIKE 'test-team%'`);
await server.db.execute(sql`DELETE FROM users WHERE clerk_id LIKE 'tmtest_%'`);
// Create test users directly in DB (clerk IDs use 'tmtest_' prefix to avoid auth test cleanup)
const [owner] = await server.db.insert(users).values({
clerkId: 'tmtest_owner',
displayName: 'Team Owner',
email: 'teamowner@test.com',
}).returning();
ownerId = owner.id;
const [member] = await server.db.insert(users).values({
clerkId: 'tmtest_member',
displayName: 'Team Member',
email: 'teammember@test.com',
}).returning();
memberId = member.id;
const [admin] = await server.db.insert(users).values({
clerkId: 'tmtest_admin',
displayName: 'Team Admin',
email: 'teamadmin@test.com',
}).returning();
adminId = admin.id;
// Override auth handler to use x-test-user-id header (via indirection object)
server._authHandler.fn = async function (request, reply) {
const testUserId = request.headers['x-test-user-id'] as string;
if (!testUserId) {
return reply.code(401).send({ error: 'Missing x-test-user-id header' });
}
request.userId = testUserId;
request.clerkId = 'test';
};
});
afterAll(async () => {
// Narrow to 'test-team%' — previously 'test-%' collided with analytics.test.ts's
// 'test-analytics' slug when files ran in parallel and wiped it mid-run, causing
// spurious 403s because the analytics team's owner was no longer a member.
await server.db.execute(sql`DELETE FROM team_members WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'test-team%')`);
await server.db.execute(sql`DELETE FROM team_capability_requests WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'test-team%')`);
await server.db.execute(sql`DELETE FROM team_capability_overrides WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'test-team%')`);
await server.db.execute(sql`DELETE FROM team_capability_policies WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'test-team%')`);
await server.db.execute(sql`DELETE FROM teams WHERE slug LIKE 'test-team%'`);
await server.db.execute(sql`DELETE FROM users WHERE clerk_id LIKE 'tmtest_%'`);
await server.close();
});
it('creates a team and auto-adds owner as member with role owner', async () => {
const response = await server.inject({
method: 'POST',
url: '/api/teams',
headers: { 'x-test-user-id': ownerId },
payload: { name: 'Test Team', slug: 'test-team-crud' },
});
expect(response.statusCode).toBe(201);
const body = JSON.parse(response.body);
expect(body.name).toBe('Test Team');
expect(body.slug).toBe('test-team-crud');
expect(body.ownerId).toBe(ownerId);
// Verify owner membership
const [membership] = await server.db
.select()
.from(teamMembers)
.where(sql`team_id = ${body.id} AND user_id = ${ownerId}`);
expect(membership).toBeDefined();
expect(membership.role).toBe('owner');
});
it('returns 409 on duplicate slug', async () => {
const response = await server.inject({
method: 'POST',
url: '/api/teams',
headers: { 'x-test-user-id': ownerId },
payload: { name: 'Another Team', slug: 'test-team-crud' },
});
expect(response.statusCode).toBe(409);
});
it('lists only teams the user belongs to', async () => {
const response = await server.inject({
method: 'GET',
url: '/api/teams',
headers: { 'x-test-user-id': ownerId },
});
expect(response.statusCode).toBe(200);
const body = JSON.parse(response.body);
expect(Array.isArray(body)).toBe(true);
const slugs = body.map((t: { slug: string }) => t.slug);
expect(slugs).toContain('test-team-crud');
});
it('non-member gets empty list', async () => {
const response = await server.inject({
method: 'GET',
url: '/api/teams',
headers: { 'x-test-user-id': memberId },
});
expect(response.statusCode).toBe(200);
const body = JSON.parse(response.body);
// memberId is not a member of any team with test- slug yet
const testTeams = body.filter((t: { slug: string }) => t.slug.startsWith('test-'));
expect(testTeams).toHaveLength(0);
});
it('gets team by slug with members', async () => {
const response = await server.inject({
method: 'GET',
url: '/api/teams/test-team-crud',
headers: { 'x-test-user-id': ownerId },
});
expect(response.statusCode).toBe(200);
const body = JSON.parse(response.body);
expect(body.slug).toBe('test-team-crud');
expect(body.members).toBeDefined();
expect(body.members.length).toBeGreaterThanOrEqual(1);
expect(body.members[0].displayName).toBe('Team Owner');
});
it('non-member gets 403 when accessing team', async () => {
const response = await server.inject({
method: 'GET',
url: '/api/teams/test-team-crud',
headers: { 'x-test-user-id': memberId },
});
expect(response.statusCode).toBe(403);
});
it('adds a member via invite (admin+)', async () => {
const response = await server.inject({
method: 'POST',
url: '/api/teams/test-team-crud/members',
headers: { 'x-test-user-id': ownerId },
payload: { email: 'teammember@test.com', role: 'member' },
});
expect(response.statusCode).toBe(201);
const body = JSON.parse(response.body);
expect(body.userId).toBe(memberId);
expect(body.role).toBe('member');
});
it('returns 409 when inviting existing member', async () => {
const response = await server.inject({
method: 'POST',
url: '/api/teams/test-team-crud/members',
headers: { 'x-test-user-id': ownerId },
payload: { email: 'teammember@test.com', role: 'member' },
});
expect(response.statusCode).toBe(409);
});
it('adds an admin member', async () => {
const response = await server.inject({
method: 'POST',
url: '/api/teams/test-team-crud/members',
headers: { 'x-test-user-id': ownerId },
payload: { email: 'teamadmin@test.com', role: 'admin' },
});
expect(response.statusCode).toBe(201);
const body = JSON.parse(response.body);
expect(body.role).toBe('admin');
});
it('member can update own roleDescription and interests', async () => {
const response = await server.inject({
method: 'PATCH',
url: `/api/teams/test-team-crud/members/${memberId}`,
headers: { 'x-test-user-id': memberId },
payload: {
roleDescription: 'Frontend developer',
interests: ['React', 'TypeScript'],
},
});
expect(response.statusCode).toBe(200);
const body = JSON.parse(response.body);
expect(body.roleDescription).toBe('Frontend developer');
expect(body.interests).toEqual(['React', 'TypeScript']);
});
it('member cannot change own role', async () => {
// Attempting to change role requires admin, but member is only 'member'
const response = await server.inject({
method: 'PATCH',
url: `/api/teams/test-team-crud/members/${memberId}`,
headers: { 'x-test-user-id': memberId },
payload: { role: 'admin' },
});
expect(response.statusCode).toBe(403);
});
it('admin can update team name', async () => {
const response = await server.inject({
method: 'PATCH',
url: '/api/teams/test-team-crud',
headers: { 'x-test-user-id': adminId },
payload: { name: 'Updated Team Name' },
});
expect(response.statusCode).toBe(200);
const body = JSON.parse(response.body);
expect(body.name).toBe('Updated Team Name');
});
it('member cannot update team name', async () => {
const response = await server.inject({
method: 'PATCH',
url: '/api/teams/test-team-crud',
headers: { 'x-test-user-id': memberId },
payload: { name: 'Should Fail' },
});
expect(response.statusCode).toBe(403);
});
it('cannot remove the team owner', async () => {
const response = await server.inject({
method: 'DELETE',
url: `/api/teams/test-team-crud/members/${ownerId}`,
headers: { 'x-test-user-id': ownerId },
});
expect(response.statusCode).toBe(403);
});
it('admin can remove a member', async () => {
const response = await server.inject({
method: 'DELETE',
url: `/api/teams/test-team-crud/members/${memberId}`,
headers: { 'x-test-user-id': adminId },
});
expect(response.statusCode).toBe(204);
// Verify member is gone
const checkResponse = await server.inject({
method: 'GET',
url: '/api/teams/test-team-crud',
headers: { 'x-test-user-id': ownerId },
});
const body = JSON.parse(checkResponse.body);
const memberIds = body.members.map((m: { userId: string }) => m.userId);
expect(memberIds).not.toContain(memberId);
});
it('does not let an admin demote the team owner', async () => {
const response = await server.inject({
method: 'PATCH',
url: `/api/teams/test-team-crud/members/${ownerId}`,
headers: { 'x-test-user-id': adminId },
payload: { role: 'member' },
});
expect(response.statusCode).toBe(403);
expect(response.json()).toEqual({ error: 'Cannot change the team owner role' });
const [membership] = await server.db.select().from(teamMembers)
.where(sql`team_id = (SELECT id FROM teams WHERE slug = 'test-team-crud') AND user_id = ${ownerId}`);
expect(membership.role).toBe('owner');
});
it('returns 401 without auth header', async () => {
const response = await server.inject({
method: 'GET',
url: '/api/teams',
});
expect(response.statusCode).toBe(401);
});
});

View File

@@ -0,0 +1,173 @@
import { createHmac } from 'node:crypto';
import Fastify, { type FastifyInstance } from 'fastify';
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import { webhookRoutes } from '../../src/routes/webhooks.js';
const SIGNING_KEY = Buffer.from('waggle-clerk-webhook-test-secret');
const SIGNING_SECRET = `whsec_${SIGNING_KEY.toString('base64')}`;
const createEvent = {
type: 'user.created',
data: {
id: 'clerk_webhook_user',
first_name: 'Ada',
last_name: 'Lovelace',
email_addresses: [{ email_address: 'ada@example.com' }],
image_url: 'https://example.com/ada.png',
},
};
function signedHeaders(payload: object, timestamp = Math.floor(Date.now() / 1000)) {
const id = 'msg_waggle_clerk_test';
const body = JSON.stringify(payload);
const signature = createHmac('sha256', SIGNING_KEY)
.update(`${id}.${timestamp}.${body}`)
.digest('base64');
return {
'svix-id': id,
'svix-timestamp': String(timestamp),
'svix-signature': `v1,${signature}`,
};
}
function createDbDouble() {
const onConflictDoNothing = vi.fn().mockResolvedValue(undefined);
const values = vi.fn(() => ({ onConflictDoNothing }));
const insert = vi.fn(() => ({ values }));
const updateWhere = vi.fn().mockResolvedValue(undefined);
const set = vi.fn(() => ({ where: updateWhere }));
const update = vi.fn(() => ({ set }));
const deleteWhere = vi.fn().mockResolvedValue(undefined);
const deleteFrom = vi.fn(() => ({ where: deleteWhere }));
return {
db: { insert, update, delete: deleteFrom },
mutations: { insert, values, update, deleteFrom },
};
}
describe('Clerk webhook authenticity', () => {
let app: FastifyInstance;
let mutations: ReturnType<typeof createDbDouble>['mutations'];
let originalSigningSecret: string | undefined;
beforeEach(async () => {
originalSigningSecret = process.env.CLERK_WEBHOOK_SIGNING_SECRET;
process.env.CLERK_WEBHOOK_SIGNING_SECRET = SIGNING_SECRET;
const dbDouble = createDbDouble();
mutations = dbDouble.mutations;
app = Fastify();
app.decorate('db', dbDouble.db as never);
await app.register(webhookRoutes);
});
afterEach(async () => {
await app.close();
if (originalSigningSecret === undefined) {
delete process.env.CLERK_WEBHOOK_SIGNING_SECRET;
} else {
process.env.CLERK_WEBHOOK_SIGNING_SECRET = originalSigningSecret;
}
});
it.each([
['user.created', createEvent.data],
['user.updated', createEvent.data],
['user.deleted', { id: createEvent.data.id }],
])('rejects an unsigned %s event before any database mutation', async (type, data) => {
const response = await app.inject({
method: 'POST',
url: '/api/webhooks/clerk',
payload: { type, data },
});
expect(response.statusCode).toBe(400);
expect(response.json()).toEqual({ error: 'Invalid webhook signature' });
expect(mutations.insert).not.toHaveBeenCalled();
expect(mutations.update).not.toHaveBeenCalled();
expect(mutations.deleteFrom).not.toHaveBeenCalled();
});
it('rejects an otherwise signed event when its timestamp is stale', async () => {
const staleTimestamp = Math.floor(Date.now() / 1000) - 301;
const response = await app.inject({
method: 'POST',
url: '/api/webhooks/clerk',
headers: signedHeaders(createEvent, staleTimestamp),
payload: createEvent,
});
expect(response.statusCode).toBe(400);
expect(mutations.insert).not.toHaveBeenCalled();
});
it('rejects a signature that was generated for a different body', async () => {
const tamperedEvent = {
...createEvent,
data: { ...createEvent.data, email_addresses: [{ email_address: 'attacker@example.com' }] },
};
const response = await app.inject({
method: 'POST',
url: '/api/webhooks/clerk',
headers: signedHeaders(createEvent),
payload: tamperedEvent,
});
expect(response.statusCode).toBe(400);
expect(mutations.insert).not.toHaveBeenCalled();
});
it('fails closed when the Clerk webhook signing secret is not configured', async () => {
delete process.env.CLERK_WEBHOOK_SIGNING_SECRET;
const response = await app.inject({
method: 'POST',
url: '/api/webhooks/clerk',
headers: signedHeaders(createEvent),
payload: createEvent,
});
expect(response.statusCode).toBe(400);
expect(mutations.insert).not.toHaveBeenCalled();
});
it('preserves a correctly signed user.created event and its field mapping', async () => {
const response = await app.inject({
method: 'POST',
url: '/api/webhooks/clerk',
headers: signedHeaders(createEvent),
payload: createEvent,
});
expect(response.statusCode).toBe(200);
expect(response.json()).toEqual({ received: true });
expect(mutations.values).toHaveBeenCalledWith({
clerkId: 'clerk_webhook_user',
displayName: 'Ada Lovelace',
email: 'ada@example.com',
avatarUrl: 'https://example.com/ada.png',
});
});
it('preserves correctly signed user.updated and user.deleted events', async () => {
const updateEvent = { ...createEvent, type: 'user.updated' };
const deleteEvent = { type: 'user.deleted', data: { id: createEvent.data.id } };
for (const event of [updateEvent, deleteEvent]) {
const response = await app.inject({
method: 'POST',
url: '/api/webhooks/clerk',
headers: signedHeaders(event),
payload: event,
});
expect(response.statusCode).toBe(200);
}
expect(mutations.update).toHaveBeenCalledOnce();
expect(mutations.deleteFrom).toHaveBeenCalledOnce();
});
});

View File

@@ -0,0 +1,19 @@
import { describe, it, expect, afterAll } from 'vitest';
import { buildServer } from '../src/index.js';
describe('Fastify server', () => {
const serverPromise = buildServer();
afterAll(async () => {
const server = await serverPromise;
await server.close();
});
it('responds to health check', async () => {
const server = await serverPromise;
const response = await server.inject({ method: 'GET', url: '/health' });
expect(response.statusCode).toBe(200);
const body = JSON.parse(response.body);
expect(body.status).toBe('ok');
});
});

View File

@@ -0,0 +1,203 @@
import { describe, it, expect } from 'vitest';
import {
resolvePermission,
filterByPermissions,
getDefaultPolicies,
riskExceedsThreshold,
type EffectivePermissions,
} from '../../src/services/team-capability-governance.js';
function makePerms(overrides?: Partial<EffectivePermissions>): EffectivePermissions {
return {
role: 'member',
allowedSources: ['native', 'skill'],
blockedTools: ['bash', 'delete_skill'],
approvalThreshold: 'medium',
overrides: new Map(),
...overrides,
};
}
describe('riskExceedsThreshold', () => {
it('high exceeds medium', () => {
expect(riskExceedsThreshold('high', 'medium')).toBe(true);
});
it('medium does not exceed medium', () => {
expect(riskExceedsThreshold('medium', 'medium')).toBe(false);
});
it('low does not exceed medium', () => {
expect(riskExceedsThreshold('low', 'medium')).toBe(false);
});
it('nothing exceeds none threshold', () => {
expect(riskExceedsThreshold('high', 'none')).toBe(false);
expect(riskExceedsThreshold('medium', 'none')).toBe(false);
expect(riskExceedsThreshold('low', 'none')).toBe(false);
});
it('medium exceeds low', () => {
expect(riskExceedsThreshold('medium', 'low')).toBe(true);
});
// P7/D15 A2b regression: 'critical' was omitted from the local risk map, so
// `?? 0` sorted it BELOW 'low' and a critical capability slipped past a 'low'
// approval threshold. Now ranked on the canonical scale.
it('critical exceeds every lower threshold', () => {
expect(riskExceedsThreshold('critical', 'low')).toBe(true);
expect(riskExceedsThreshold('critical', 'medium')).toBe(true);
expect(riskExceedsThreshold('critical', 'high')).toBe(true);
});
it('critical does not exceed critical', () => {
expect(riskExceedsThreshold('critical', 'critical')).toBe(false);
});
it('nothing exceeds the none threshold, including critical', () => {
expect(riskExceedsThreshold('critical', 'none')).toBe(false);
});
it('low does not exceed low', () => {
expect(riskExceedsThreshold('low', 'low')).toBe(false);
});
});
describe('resolvePermission', () => {
it('override approved returns allowed immediately', () => {
const perms = makePerms({
overrides: new Map([['dangerous_tool', 'approved']]),
});
// Even if source not in allowedSources, override wins
expect(resolvePermission(perms, 'dangerous_tool', 'plugin', 'high')).toBe('allowed');
});
it('override blocked returns blocked immediately', () => {
const perms = makePerms({
overrides: new Map([['some_skill', 'blocked']]),
});
// Even if source is allowed and tool not blocked, override wins
expect(resolvePermission(perms, 'some_skill', 'native', 'low')).toBe('blocked');
});
it('source not allowed returns source_not_allowed', () => {
const perms = makePerms({ allowedSources: ['native'] });
expect(resolvePermission(perms, 'some_plugin', 'plugin', 'low')).toBe('source_not_allowed');
});
it('blocked tool returns blocked', () => {
const perms = makePerms();
expect(resolvePermission(perms, 'bash', 'native', 'low')).toBe('blocked');
});
it('risk exceeds threshold returns needs_approval', () => {
const perms = makePerms({ approvalThreshold: 'medium' });
expect(resolvePermission(perms, 'safe_tool', 'native', 'high')).toBe('needs_approval');
});
it('risk within threshold returns allowed', () => {
const perms = makePerms({ approvalThreshold: 'medium' });
expect(resolvePermission(perms, 'safe_tool', 'native', 'low')).toBe('allowed');
});
it('threshold none means everything allowed (no approval needed)', () => {
const perms = makePerms({ approvalThreshold: 'none' });
expect(resolvePermission(perms, 'safe_tool', 'native', 'high')).toBe('allowed');
});
it('blocked tool takes priority over source check', () => {
const perms = makePerms({
allowedSources: ['native'],
blockedTools: ['bash'],
});
// bash is native (allowed source) but blocked tool — should be blocked
expect(resolvePermission(perms, 'bash', 'native', 'low')).toBe('blocked');
});
it('defaults risk to low when not provided', () => {
const perms = makePerms({ approvalThreshold: 'low' });
// low does not exceed low, so allowed
expect(resolvePermission(perms, 'safe_tool', 'native')).toBe('allowed');
});
});
describe('filterByPermissions', () => {
it('removes blocked capabilities', () => {
const perms = makePerms();
const caps = [
{ name: 'bash', type: 'native' },
{ name: 'safe_tool', type: 'native', risk: 'low' },
];
const results = filterByPermissions(perms, caps);
expect(results).toHaveLength(2);
expect(results[0].result).toBe('blocked');
expect(results[1].result).toBe('allowed');
});
it('keeps approved overrides even if source not in policy', () => {
const perms = makePerms({
allowedSources: ['native'],
overrides: new Map([['my_plugin', 'approved']]),
});
const caps = [{ name: 'my_plugin', type: 'plugin', risk: 'high' }];
const results = filterByPermissions(perms, caps);
expect(results[0].result).toBe('allowed');
});
it('blocks override-blocked even if policy would allow', () => {
const perms = makePerms({
allowedSources: ['native', 'skill'],
blockedTools: [],
overrides: new Map([['good_skill', 'blocked']]),
});
const caps = [{ name: 'good_skill', type: 'skill', risk: 'low' }];
const results = filterByPermissions(perms, caps);
expect(results[0].result).toBe('blocked');
});
it('marks source_not_allowed for unknown sources', () => {
const perms = makePerms({ allowedSources: ['native'] });
const caps = [{ name: 'mcp_tool', type: 'mcp' }];
const results = filterByPermissions(perms, caps);
expect(results[0].result).toBe('source_not_allowed');
});
it('marks needs_approval when risk exceeds threshold', () => {
const perms = makePerms({ approvalThreshold: 'low' });
const caps = [{ name: 'risky_skill', type: 'skill', risk: 'medium' }];
const results = filterByPermissions(perms, caps);
expect(results[0].result).toBe('needs_approval');
});
});
describe('getDefaultPolicies', () => {
it('returns 3 role policies', () => {
const policies = getDefaultPolicies();
expect(policies).toHaveLength(3);
const roles = policies.map((p) => p.role);
expect(roles).toContain('owner');
expect(roles).toContain('admin');
expect(roles).toContain('member');
});
it('owner has all sources and no blocks', () => {
const owner = getDefaultPolicies().find((p) => p.role === 'owner')!;
expect(owner.allowedSources).toEqual(['native', 'skill', 'plugin', 'mcp']);
expect(owner.blockedTools).toEqual([]);
expect(owner.approvalThreshold).toBe('none');
});
it('admin has all sources and no blocks', () => {
const admin = getDefaultPolicies().find((p) => p.role === 'admin')!;
expect(admin.allowedSources).toEqual(['native', 'skill', 'plugin', 'mcp']);
expect(admin.blockedTools).toEqual([]);
expect(admin.approvalThreshold).toBe('none');
});
it('member has restricted sources and blocked tools', () => {
const member = getDefaultPolicies().find((p) => p.role === 'member')!;
expect(member.allowedSources).toEqual(['native', 'skill']);
expect(member.blockedTools).toEqual(['bash', 'delete_skill']);
expect(member.approvalThreshold).toBe('medium');
});
});

View File

@@ -0,0 +1,574 @@
import { describe, it, expect, beforeAll, afterAll, vi } from 'vitest';
import type { Mock } from 'vitest';
import type { WebSocket } from 'ws';
import type { Task, SuggestionEntry } from '@waggle/shared';
import type { AuthenticateFn } from '../../src/plugins/auth.js';
import { ConnectionManager } from '../../src/ws/connection-manager.js';
import { connectionManager, setWsTokenVerifier } from '../../src/ws/gateway.js';
/** A minimal mock WebSocket exposing the surface ConnectionManager touches. */
interface MockWebSocket {
readyState: number;
OPEN: number;
send: Mock;
}
/** Build a mock WebSocket whose `send` is a vitest mock the tests can assert on. */
function mockWs(readyState = 1): MockWebSocket {
return { readyState, OPEN: 1, send: vi.fn() };
}
/**
* Cast a mock WebSocket to the real `ws.WebSocket` type at ConnectionManager
* boundaries. The real type has a large surface; ConnectionManager only reads
* `readyState`/`OPEN` and calls `send`, so the minimal mock is sound here.
*/
function asWs(ws: MockWebSocket): WebSocket {
return ws as unknown as WebSocket;
}
/**
* Create a structurally valid JWT with a given payload.
* Header: {"alg":"HS256","typ":"JWT"}, signature: fake.
* This is NOT cryptographically signed — it's for testing JWT structure validation.
*/
function makeTestJwt(payload: Record<string, unknown>): string {
const header = Buffer.from(JSON.stringify({ alg: 'HS256', typ: 'JWT' }))
.toString('base64url');
const body = Buffer.from(JSON.stringify(payload)).toString('base64url');
const signature = Buffer.from('test-signature').toString('base64url');
return `${header}.${body}.${signature}`;
}
// ─── ConnectionManager unit tests ───────────────────────────────────────────
describe('ConnectionManager', () => {
it('tracks connections by team and user', () => {
const cm = new ConnectionManager();
const ws = mockWs();
cm.add('team1', 'user1', asWs(ws));
expect(cm.getConnectedUsers('team1')).toEqual(['user1']);
cm.remove('team1', 'user1');
expect(cm.getConnectedUsers('team1')).toEqual([]);
});
it('returns empty array for unknown team', () => {
const cm = new ConnectionManager();
expect(cm.getConnectedUsers('nonexistent')).toEqual([]);
});
it('removes team entry when last user disconnects', () => {
const cm = new ConnectionManager();
const ws = mockWs();
cm.add('team1', 'user1', asWs(ws));
expect(cm.getTeamCount()).toBe(1);
cm.remove('team1', 'user1');
expect(cm.getTeamCount()).toBe(0);
});
it('tracks multiple users in same team', () => {
const cm = new ConnectionManager();
const ws1 = mockWs();
const ws2 = mockWs();
cm.add('team1', 'user1', asWs(ws1));
cm.add('team1', 'user2', asWs(ws2));
expect(cm.getConnectedUsers('team1')).toEqual(['user1', 'user2']);
});
it('tracks users across multiple teams', () => {
const cm = new ConnectionManager();
const ws1 = mockWs();
const ws2 = mockWs();
cm.add('team1', 'user1', asWs(ws1));
cm.add('team2', 'user2', asWs(ws2));
expect(cm.getConnectedUsers('team1')).toEqual(['user1']);
expect(cm.getConnectedUsers('team2')).toEqual(['user2']);
expect(cm.getTeamCount()).toBe(2);
});
it('broadcasts to all team members', () => {
const cm = new ConnectionManager();
const ws1 = mockWs();
const ws2 = mockWs();
cm.add('team1', 'user1', asWs(ws1));
cm.add('team1', 'user2', asWs(ws2));
cm.broadcast('team1', { type: 'task_update', task: {} as unknown as Task });
expect(ws1.send).toHaveBeenCalledOnce();
expect(ws2.send).toHaveBeenCalledOnce();
const sentData = JSON.parse(ws1.send.mock.calls[0][0] as string);
expect(sentData.type).toBe('task_update');
});
it('excludes user from broadcast', () => {
const cm = new ConnectionManager();
const ws1 = mockWs();
const ws2 = mockWs();
cm.add('team1', 'user1', asWs(ws1));
cm.add('team1', 'user2', asWs(ws2));
cm.broadcast('team1', { type: 'task_update', task: {} as unknown as Task }, 'user1');
expect(ws1.send).not.toHaveBeenCalled();
expect(ws2.send).toHaveBeenCalledOnce();
});
it('skips sockets that are not OPEN', () => {
const cm = new ConnectionManager();
const wsOpen = mockWs(1);
const wsClosed = mockWs(3); // readyState 3 = CLOSED
cm.add('team1', 'user1', asWs(wsOpen));
cm.add('team1', 'user2', asWs(wsClosed));
cm.broadcast('team1', { type: 'task_update', task: {} as unknown as Task });
expect(wsOpen.send).toHaveBeenCalledOnce();
expect(wsClosed.send).not.toHaveBeenCalled();
});
it('sends to specific user', () => {
const cm = new ConnectionManager();
const ws1 = mockWs();
const ws2 = mockWs();
cm.add('team1', 'user1', asWs(ws1));
cm.add('team1', 'user2', asWs(ws2));
cm.sendTo('team1', 'user1', { type: 'suggestion', suggestion: {} as unknown as SuggestionEntry });
expect(ws1.send).toHaveBeenCalledOnce();
expect(ws2.send).not.toHaveBeenCalled();
const sentData = JSON.parse(ws1.send.mock.calls[0][0] as string);
expect(sentData.type).toBe('suggestion');
});
it('sendTo does nothing for nonexistent user', () => {
const cm = new ConnectionManager();
// Should not throw
cm.sendTo('team1', 'nobody', { type: 'task_update', task: {} as unknown as Task });
});
it('sendTo does nothing for closed socket', () => {
const cm = new ConnectionManager();
const wsClosed = mockWs(3);
cm.add('team1', 'user1', asWs(wsClosed));
cm.sendTo('team1', 'user1', { type: 'task_update', task: {} as unknown as Task });
expect(wsClosed.send).not.toHaveBeenCalled();
});
it('broadcast does nothing for nonexistent team', () => {
const cm = new ConnectionManager();
// Should not throw
cm.broadcast('nonexistent', { type: 'task_update', task: {} as unknown as Task });
});
it('replaces connection when same user re-adds', () => {
const cm = new ConnectionManager();
const ws1 = mockWs();
const ws2 = mockWs();
cm.add('team1', 'user1', asWs(ws1));
cm.add('team1', 'user1', asWs(ws2)); // replace
cm.broadcast('team1', { type: 'task_update', task: {} as unknown as Task });
expect(ws1.send).not.toHaveBeenCalled();
expect(ws2.send).toHaveBeenCalledOnce();
expect(cm.getConnectedUsers('team1')).toEqual(['user1']);
});
// ── 11F-6: WebSocket lifecycle tests ──────────────────────────────────
it('multiple clients with one disconnect: broadcast still reaches remaining 2', () => {
const cm = new ConnectionManager();
const ws1 = mockWs();
const ws2 = mockWs();
const ws3 = mockWs();
// Register 3 clients in a team
cm.add('team1', 'user1', asWs(ws1));
cm.add('team1', 'user2', asWs(ws2));
cm.add('team1', 'user3', asWs(ws3));
expect(cm.getConnectedUsers('team1')).toEqual(['user1', 'user2', 'user3']);
// Disconnect user2
cm.remove('team1', 'user2');
expect(cm.getConnectedUsers('team1')).toEqual(['user1', 'user3']);
// Broadcast — should reach user1 and user3 only
cm.broadcast('team1', { type: 'task_update', task: {} as unknown as Task });
expect(ws1.send).toHaveBeenCalledOnce();
expect(ws2.send).not.toHaveBeenCalled();
expect(ws3.send).toHaveBeenCalledOnce();
// Team is still tracked (not removed since 2 users remain)
expect(cm.getTeamCount()).toBe(1);
});
it('reconnection with same userId: no duplicate entries, clean replacement', () => {
const cm = new ConnectionManager();
const wsOriginal = mockWs();
const wsReconnect = mockWs();
// Initial connection
cm.add('team1', 'user1', asWs(wsOriginal));
expect(cm.getConnectedUsers('team1')).toEqual(['user1']);
// Simulate disconnect
cm.remove('team1', 'user1');
expect(cm.getConnectedUsers('team1')).toEqual([]);
// Team entry should be cleaned up since last user left
expect(cm.getTeamCount()).toBe(0);
// Reconnect with same userId
cm.add('team1', 'user1', asWs(wsReconnect));
expect(cm.getConnectedUsers('team1')).toEqual(['user1']);
expect(cm.getTeamCount()).toBe(1);
// Broadcast should only reach the reconnected socket
cm.broadcast('team1', { type: 'task_update', task: {} as unknown as Task });
expect(wsOriginal.send).not.toHaveBeenCalled();
expect(wsReconnect.send).toHaveBeenCalledOnce();
// No duplicate user entries
expect(cm.getConnectedUsers('team1')).toHaveLength(1);
});
});
// ─── WebSocket Gateway integration tests ────────────────────────────────────
// These require PostgreSQL + Redis running (ports 5434 / 6381)
describe('WebSocket Gateway (integration)', () => {
let server: Awaited<ReturnType<typeof import('../../src/index.js').buildServer>>;
let address: string;
let userId: string;
let outsiderUserId: string;
let clerkId: string;
let teamSlug: string;
let teamId: string;
/** A structurally valid JWT whose sub matches our test user's clerkId */
let validJwt: string;
let outsiderJwt: string;
beforeAll(async () => {
const { buildServer } = await import('../../src/index.js');
const { sql: drizzleSql } = await import('drizzle-orm');
server = await buildServer();
// Override auth to bypass Clerk for REST routes
const testAuthHandler: AuthenticateFn = async (req, reply) => {
const testUserId = req.headers['x-test-user-id'] as string;
if (!testUserId) {
await reply.code(401).send({ error: 'Missing test user' });
return;
}
req.userId = testUserId;
req.clerkId = 'test';
};
server._authHandler.fn = testAuthHandler;
// Clean up leftover data from previous runs
const { users, teams, teamMembers } = await import('../../src/db/schema.js');
await server.db.execute(drizzleSql`DELETE FROM team_members WHERE user_id IN (SELECT id FROM users WHERE clerk_id LIKE 'wstest_%')`);
await server.db.execute(drizzleSql`DELETE FROM messages WHERE sender_id IN (SELECT id FROM users WHERE clerk_id LIKE 'wstest_%')`);
await server.db.execute(drizzleSql`DELETE FROM team_capability_requests WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'ws-test-team-%')`);
await server.db.execute(drizzleSql`DELETE FROM team_capability_overrides WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'ws-test-team-%')`);
await server.db.execute(drizzleSql`DELETE FROM team_capability_policies WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'ws-test-team-%')`);
await server.db.execute(drizzleSql`DELETE FROM teams WHERE slug LIKE 'ws-test-team-%'`);
await server.db.execute(drizzleSql`DELETE FROM users WHERE clerk_id LIKE 'wstest_%'`);
// Create test user and team with unique IDs
const suffix = Date.now();
clerkId = `wstest_user_${suffix}`;
const [user] = await server.db
.insert(users)
.values({
clerkId,
displayName: 'WS User',
email: `wsuser_${suffix}@test.com`,
})
.returning();
userId = user.id;
const outsiderClerkId = `wstest_outsider_${suffix}`;
const [outsider] = await server.db
.insert(users)
.values({
clerkId: outsiderClerkId,
displayName: 'WS Outsider',
email: `wsoutsider_${suffix}@test.com`,
})
.returning();
outsiderUserId = outsider.id;
// Build a valid test JWT with the user's clerkId as `sub`
validJwt = makeTestJwt({ sub: clerkId, iat: Math.floor(Date.now() / 1000) });
outsiderJwt = makeTestJwt({ sub: outsiderClerkId, iat: Math.floor(Date.now() / 1000) });
// Override the WS token verifier so tests don't need a real Clerk secret key.
// The verifier accepts any structurally valid JWT and returns its decoded `sub`.
setWsTokenVerifier(async (token: string) => {
const parts = token.split('.');
const payload = JSON.parse(Buffer.from(parts[1], 'base64url').toString());
if (typeof payload.sub !== 'string') throw new Error('Missing sub');
return { sub: payload.sub };
});
teamSlug = `ws-test-team-${suffix}`;
const [team] = await server.db
.insert(teams)
.values({ name: 'WS Team', slug: teamSlug, ownerId: userId })
.returning();
teamId = team.id;
await server.db
.insert(teamMembers)
.values({ teamId: team.id, userId, role: 'owner' });
// Start listening on a random port
await server.listen({ port: 0, host: '127.0.0.1' });
const addr = server.server.address();
address = typeof addr === 'string' ? addr : `127.0.0.1:${addr?.port}`;
});
afterAll(async () => {
// Clear the WS token verifier override
setWsTokenVerifier(null);
if (!server) return;
const { sql } = await import('drizzle-orm');
await server.db.execute(
sql`DELETE FROM team_members WHERE user_id IN (SELECT id FROM users WHERE clerk_id LIKE 'wstest_%')`,
);
await server.db.execute(
sql`DELETE FROM messages WHERE sender_id IN (SELECT id FROM users WHERE clerk_id LIKE 'wstest_%')`,
);
await server.db.execute(sql`DELETE FROM team_capability_requests WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'ws-test-team-%')`);
await server.db.execute(sql`DELETE FROM team_capability_overrides WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'ws-test-team-%')`);
await server.db.execute(sql`DELETE FROM team_capability_policies WHERE team_id IN (SELECT id FROM teams WHERE slug LIKE 'ws-test-team-%')`);
await server.db.execute(sql`DELETE FROM teams WHERE slug LIKE 'ws-test-team-%'`);
await server.db.execute(
sql`DELETE FROM users WHERE clerk_id LIKE 'wstest_%'`,
);
await server.close();
});
function connectWs(): Promise<{ ws: import('ws').WebSocket; messages: Record<string, unknown>[] }> {
return new Promise((resolve, reject) => {
// Dynamic import to avoid issues if ws isn't available at parse time
import('ws').then(({ default: WS }) => {
const ws = new WS(`ws://${address}/ws`);
const msgs: Record<string, unknown>[] = [];
ws.on('message', (data: Buffer) => msgs.push(JSON.parse(data.toString())));
ws.on('open', () => resolve({ ws, messages: msgs }));
ws.on('error', reject);
});
});
}
function wait(ms: number) {
return new Promise((r) => setTimeout(r, ms));
}
/** Wait until messages array has at least `count` entries, or timeout. */
async function waitForMessages(messages: Record<string, unknown>[], count: number, timeoutMs = 3000) {
const start = Date.now();
while (messages.length < count && Date.now() - start < timeoutMs) {
await wait(50);
}
}
it('connects and authenticates via WebSocket', async () => {
const { ws, messages } = await connectWs();
ws.send(JSON.stringify({ type: 'authenticate', token: validJwt }));
await waitForMessages(messages, 1);
expect(messages).toHaveLength(1);
expect(messages[0]).toEqual({ type: 'authenticated', userId });
ws.close();
});
it('rejects join_team before authentication', async () => {
const { ws, messages } = await connectWs();
ws.send(JSON.stringify({ type: 'join_team', teamSlug }));
await waitForMessages(messages, 1);
expect(messages[0]).toEqual({ type: 'error', message: 'Not authenticated' });
ws.close();
});
it('joins team room after authentication', async () => {
const { ws, messages } = await connectWs();
ws.send(JSON.stringify({ type: 'authenticate', token: validJwt }));
await waitForMessages(messages, 1);
ws.send(JSON.stringify({ type: 'join_team', teamSlug }));
await waitForMessages(messages, 2);
expect(messages[1]).toEqual({ type: 'joined_team', teamSlug });
ws.close();
});
it('rejects an authenticated non-member joining an existing team', async () => {
const { ws, messages } = await connectWs();
ws.send(JSON.stringify({ type: 'authenticate', token: outsiderJwt }));
await waitForMessages(messages, 1);
expect(messages[0]).toEqual({ type: 'authenticated', userId: outsiderUserId });
ws.send(JSON.stringify({ type: 'join_team', teamSlug }));
await waitForMessages(messages, 2);
expect(messages[1]).toEqual({ type: 'error', message: 'Team not found' });
expect(connectionManager.getConnectedUsers(teamId)).not.toContain(outsiderUserId);
ws.close();
});
it('clears the joined team when a socket authenticates as a different user', async () => {
const { ws, messages } = await connectWs();
ws.send(JSON.stringify({ type: 'authenticate', token: validJwt }));
await waitForMessages(messages, 1);
ws.send(JSON.stringify({ type: 'join_team', teamSlug }));
await waitForMessages(messages, 2);
ws.send(JSON.stringify({ type: 'authenticate', token: outsiderJwt }));
await waitForMessages(messages, 3);
expect(messages[2]).toEqual({ type: 'authenticated', userId: outsiderUserId });
expect(connectionManager.getConnectedUsers(teamId)).not.toContain(userId);
ws.send(
JSON.stringify({
type: 'send_message',
teamSlug,
messageType: 'broadcast',
subtype: 'discovery',
content: { text: 'reauthenticated outsider' },
}),
);
await waitForMessages(messages, 4);
expect(messages[3]).toEqual({ type: 'error', message: 'Not in a team' });
ws.close();
});
it('returns error for nonexistent team', async () => {
const { ws, messages } = await connectWs();
ws.send(JSON.stringify({ type: 'authenticate', token: validJwt }));
await waitForMessages(messages, 1);
ws.send(JSON.stringify({ type: 'join_team', teamSlug: 'does-not-exist' }));
await waitForMessages(messages, 2);
expect(messages[1]).toEqual({ type: 'error', message: 'Team not found' });
ws.close();
});
it('rejects send_message before joining team', async () => {
const { ws, messages } = await connectWs();
ws.send(JSON.stringify({ type: 'authenticate', token: validJwt }));
await waitForMessages(messages, 1);
ws.send(
JSON.stringify({
type: 'send_message',
teamSlug,
messageType: 'broadcast',
subtype: 'discovery',
content: { text: 'hello' },
}),
);
await waitForMessages(messages, 2);
expect(messages[1]).toEqual({ type: 'error', message: 'Not in a team' });
ws.close();
});
it('handles invalid JSON gracefully', async () => {
const { ws, messages } = await connectWs();
ws.send('this is not json');
await wait(200);
expect(messages[0]).toEqual({ type: 'error', message: 'Invalid message' });
ws.close();
});
// ─── JWT auth security tests ──────────────────────────────────────────────
it('rejects plain userId string as token (not a JWT)', async () => {
const { ws, messages } = await connectWs();
// Sending a raw userId (UUID) should be rejected — it's not a JWT
ws.send(JSON.stringify({ type: 'authenticate', token: userId }));
await waitForMessages(messages, 1);
expect(messages[0]).toEqual({
type: 'error',
message: 'Invalid token: must be a valid JWT',
});
ws.close();
});
it('rejects random non-JWT string as token', async () => {
const { ws, messages } = await connectWs();
ws.send(JSON.stringify({ type: 'authenticate', token: 'not-a-jwt-token' }));
await waitForMessages(messages, 1);
expect(messages[0]).toEqual({
type: 'error',
message: 'Invalid token: must be a valid JWT',
});
ws.close();
});
it('rejects JWT with nonexistent user (unknown clerkId)', async () => {
const { ws, messages } = await connectWs();
const fakeJwt = makeTestJwt({ sub: 'clerk_user_does_not_exist', iat: Math.floor(Date.now() / 1000) });
ws.send(JSON.stringify({ type: 'authenticate', token: fakeJwt }));
await waitForMessages(messages, 1);
expect(messages[0]).toEqual({
type: 'error',
message: 'User not found',
});
ws.close();
});
it('authenticates with valid JWT and maps clerkId to internal userId', async () => {
const { ws, messages } = await connectWs();
ws.send(JSON.stringify({ type: 'authenticate', token: validJwt }));
await waitForMessages(messages, 1);
expect(messages[0]).toEqual({ type: 'authenticated', userId });
ws.close();
});
});