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

@@ -1,241 +0,0 @@
import { eq, and, inArray } from 'drizzle-orm';
import { agents, agentGroups, agentGroupMembers, agentJobs } from '../db/schema.js';
import type { Db } from '../db/connection.js';
export class AgentGroupMemberNotFoundError extends Error {}
export class AgentService {
constructor(private db: Db) {}
private async groupMembersOwned(userId: string, agentIds: string[]): Promise<boolean> {
const uniqueAgentIds = [...new Set(agentIds)];
if (uniqueAgentIds.length === 0) return true;
const ownedAgents = await this.db
.select({ id: agents.id })
.from(agents)
.where(and(eq(agents.userId, userId), inArray(agents.id, uniqueAgentIds)));
return ownedAgents.length === uniqueAgentIds.length;
}
private async assertGroupMembersOwned(userId: string, agentIds: string[]): Promise<void> {
if (!(await this.groupMembersOwned(userId, agentIds))) {
throw new AgentGroupMemberNotFoundError();
}
}
async create(userId: string, data: {
name: string;
role?: string;
systemPrompt?: string;
model?: string;
tools?: string[];
config?: Record<string, unknown>;
teamId?: string;
}) {
const [agent] = await this.db.insert(agents).values({
userId,
name: data.name,
role: data.role,
systemPrompt: data.systemPrompt,
model: data.model ?? 'claude-haiku-4-5',
tools: data.tools ?? [],
config: data.config ?? {},
teamId: data.teamId,
}).returning();
return agent;
}
async list(userId: string) {
return this.db
.select()
.from(agents)
.where(eq(agents.userId, userId));
}
async getById(id: string) {
const [agent] = await this.db
.select()
.from(agents)
.where(eq(agents.id, id))
.limit(1);
return agent ?? null;
}
async update(id: string, userId: string, data: {
name?: string;
role?: string;
systemPrompt?: string;
model?: string;
tools?: string[];
config?: Record<string, unknown>;
}) {
const setData: Record<string, unknown> = {};
if (data.name !== undefined) setData.name = data.name;
if (data.role !== undefined) setData.role = data.role;
if (data.systemPrompt !== undefined) setData.systemPrompt = data.systemPrompt;
if (data.model !== undefined) setData.model = data.model;
if (data.tools !== undefined) setData.tools = data.tools;
if (data.config !== undefined) setData.config = data.config;
if (Object.keys(setData).length === 0) return null;
const [updated] = await this.db
.update(agents)
.set(setData)
.where(and(eq(agents.id, id), eq(agents.userId, userId)))
.returning();
return updated ?? null;
}
async delete(id: string, userId: string) {
// First remove agent from any groups
await this.db
.delete(agentGroupMembers)
.where(eq(agentGroupMembers.agentId, id));
const result = await this.db
.delete(agents)
.where(and(eq(agents.id, id), eq(agents.userId, userId)))
.returning();
return result.length > 0;
}
async createGroup(userId: string, data: {
name: string;
description?: string;
strategy: string;
members: Array<{ agentId: string; roleInGroup?: string; executionOrder?: number }>;
}) {
await this.assertGroupMembersOwned(userId, data.members.map((member) => member.agentId));
return this.db.transaction(async (tx) => {
const [group] = await tx.insert(agentGroups).values({
userId,
name: data.name,
description: data.description,
strategy: data.strategy,
}).returning();
if (data.members.length > 0) {
await tx.insert(agentGroupMembers).values(
data.members.map((m) => ({
groupId: group.id,
agentId: m.agentId,
roleInGroup: m.roleInGroup ?? 'worker',
executionOrder: m.executionOrder ?? 0,
})),
);
}
const members = await tx
.select()
.from(agentGroupMembers)
.where(eq(agentGroupMembers.groupId, group.id));
return { ...group, members };
});
}
async listGroups(userId: string) {
return this.db
.select()
.from(agentGroups)
.where(eq(agentGroups.userId, userId));
}
async getGroup(groupId: string, userId: string) {
const [group] = await this.db
.select()
.from(agentGroups)
.where(and(eq(agentGroups.id, groupId), eq(agentGroups.userId, userId)))
.limit(1);
if (!group) return null;
const members = await this.db
.select()
.from(agentGroupMembers)
.where(eq(agentGroupMembers.groupId, groupId));
if (!(await this.groupMembersOwned(userId, members.map((member) => member.agentId)))) {
return null;
}
return { ...group, members };
}
async updateGroup(groupId: string, userId: string, data: {
name?: string;
description?: string;
strategy?: string;
members?: Array<{ agentId: string; roleInGroup?: string; executionOrder?: number }>;
}) {
// Verify ownership
const existing = await this.getGroup(groupId, userId);
if (!existing) return null;
if (data.members) {
await this.assertGroupMembersOwned(userId, data.members.map((member) => member.agentId));
}
return this.db.transaction(async (tx) => {
// Update group fields if any provided
const updates: Record<string, unknown> = {};
if (data.name != null) updates.name = data.name;
if (data.description != null) updates.description = data.description;
if (data.strategy != null) updates.strategy = data.strategy;
if (Object.keys(updates).length > 0) {
updates.updatedAt = new Date();
await tx.update(agentGroups).set(updates).where(eq(agentGroups.id, groupId));
}
// Replace members if provided
if (data.members) {
await tx.delete(agentGroupMembers).where(eq(agentGroupMembers.groupId, groupId));
if (data.members.length > 0) {
await tx.insert(agentGroupMembers).values(
data.members.map(m => ({
groupId,
agentId: m.agentId,
roleInGroup: m.roleInGroup ?? 'worker',
executionOrder: m.executionOrder ?? 0,
})),
);
}
}
// Return updated group with members
const [group] = await tx.select().from(agentGroups).where(eq(agentGroups.id, groupId));
const members = await tx.select().from(agentGroupMembers).where(eq(agentGroupMembers.groupId, groupId));
return { ...group, members };
});
}
async deleteGroup(groupId: string, userId: string): Promise<boolean> {
const existing = await this.getGroup(groupId, userId);
if (!existing) return false;
await this.db.transaction(async (tx) => {
await tx.delete(agentGroupMembers).where(eq(agentGroupMembers.groupId, groupId));
await tx.delete(agentGroups).where(eq(agentGroups.id, groupId));
});
return true;
}
async createJob(userId: string, data: {
teamId: string;
jobType: string;
input: Record<string, unknown>;
}) {
const [job] = await this.db.insert(agentJobs).values({
userId,
teamId: data.teamId,
jobType: data.jobType,
status: 'queued',
input: data.input,
}).returning();
return job;
}
}

View File

@@ -1,291 +0,0 @@
import { eq, and, sql, count, desc, gte, lt } from 'drizzle-orm';
import {
teamMembers, users, tasks, agentAuditLog, agentJobs,
teamCapabilityRequests, messages,
} from '../db/schema.js';
import type { Db } from '../db/connection.js';
export interface AnalyticsResponse {
activeUsers: { daily: number; weekly: number; monthly: number };
tokenUsage: {
total: number;
byUser: Array<{ userId: string; name: string; tokens: number; cost: number }>;
};
topTools: Array<{ name: string; invocations: number }>;
topCommands: Array<{ name: string; count: number }>;
capabilityGaps: Array<{ tool: string; requestCount: number; suggestion: string }>;
performanceTrends: {
correctionRate: number;
correctionTrend: number;
avgResponseTime: number;
};
}
export class AnalyticsService {
constructor(private db: Db) {}
async getAnalytics(teamId: string): Promise<AnalyticsResponse> {
const [activeUsers, tokenUsage, topTools, topCommands, capabilityGaps, performanceTrends] =
await Promise.all([
this.getActiveUsers(teamId),
this.getTokenUsage(teamId),
this.getTopTools(teamId),
this.getTopCommands(teamId),
this.getCapabilityGaps(teamId),
this.getPerformanceTrends(teamId),
]);
return {
activeUsers,
tokenUsage,
topTools,
topCommands,
capabilityGaps,
performanceTrends,
};
}
/**
* Count active users based on audit log activity within time windows.
* Falls back to member count if no activity found.
*/
private async getActiveUsers(teamId: string) {
const now = new Date();
const oneDayAgo = new Date(now.getTime() - 24 * 60 * 60 * 1000);
const oneWeekAgo = new Date(now.getTime() - 7 * 24 * 60 * 60 * 1000);
const oneMonthAgo = new Date(now.getTime() - 30 * 24 * 60 * 60 * 1000);
const [dailyResult] = await this.db
.select({ count: sql<number>`count(distinct ${agentAuditLog.userId})` })
.from(agentAuditLog)
.where(and(
eq(agentAuditLog.teamId, teamId),
gte(agentAuditLog.createdAt, oneDayAgo),
));
const [weeklyResult] = await this.db
.select({ count: sql<number>`count(distinct ${agentAuditLog.userId})` })
.from(agentAuditLog)
.where(and(
eq(agentAuditLog.teamId, teamId),
gte(agentAuditLog.createdAt, oneWeekAgo),
));
const [monthlyResult] = await this.db
.select({ count: sql<number>`count(distinct ${agentAuditLog.userId})` })
.from(agentAuditLog)
.where(and(
eq(agentAuditLog.teamId, teamId),
gte(agentAuditLog.createdAt, oneMonthAgo),
));
return {
daily: Number(dailyResult?.count ?? 0),
weekly: Number(weeklyResult?.count ?? 0),
monthly: Number(monthlyResult?.count ?? 0),
};
}
/**
* Compute token usage from completed jobs.
* Since we don't have a dedicated token tracking table, we estimate from
* job outputs that may contain token counts, or fall back to job counts as proxy.
*/
private async getTokenUsage(teamId: string) {
// Get all members for this team
const members = await this.db
.select({
userId: teamMembers.userId,
displayName: users.displayName,
})
.from(teamMembers)
.innerJoin(users, eq(teamMembers.userId, users.id))
.where(eq(teamMembers.teamId, teamId));
// Count completed jobs per user as a proxy for usage
const jobCounts = await this.db
.select({
userId: agentJobs.userId,
jobCount: sql<number>`count(*)`,
})
.from(agentJobs)
.where(and(
eq(agentJobs.teamId, teamId),
eq(agentJobs.status, 'completed'),
))
.groupBy(agentJobs.userId);
const jobCountMap = new Map(jobCounts.map((j) => [j.userId, Number(j.jobCount)]));
// Estimate tokens: ~1000 tokens per completed job (rough proxy)
const TOKENS_PER_JOB = 1000;
const COST_PER_1K_TOKENS = 0.005;
const byUser = members.map((m) => {
const jobs = jobCountMap.get(m.userId) ?? 0;
const tokens = jobs * TOKENS_PER_JOB;
return {
userId: m.userId,
name: m.displayName,
tokens,
cost: Math.round((tokens / 1000) * COST_PER_1K_TOKENS * 100) / 100,
};
});
const total = byUser.reduce((sum, u) => sum + u.tokens, 0);
return { total, byUser };
}
/**
* Get top tools from audit log action types (tool invocations are logged as actions).
*/
private async getTopTools(teamId: string) {
const results = await this.db
.select({
name: agentAuditLog.actionType,
invocations: sql<number>`count(*)`,
})
.from(agentAuditLog)
.where(and(
eq(agentAuditLog.teamId, teamId),
))
.groupBy(agentAuditLog.actionType)
.orderBy(desc(sql`count(*)`))
.limit(10);
return results.map((r) => ({
name: r.name,
invocations: Number(r.invocations),
}));
}
/**
* Get top commands from audit log entries where actionType starts with 'command:'.
* Falls back to all action types containing 'command' or starting with '/'.
*/
private async getTopCommands(teamId: string) {
const results = await this.db
.select({
name: agentAuditLog.actionType,
count: sql<number>`count(*)`,
})
.from(agentAuditLog)
.where(and(
eq(agentAuditLog.teamId, teamId),
sql`${agentAuditLog.actionType} LIKE 'command:%'`,
))
.groupBy(agentAuditLog.actionType)
.orderBy(desc(sql`count(*)`))
.limit(10);
return results.map((r) => {
const stripped = r.name.replace(/^command:/, '');
return {
name: stripped.startsWith('/') ? stripped : `/${stripped}`,
count: Number(r.count),
};
});
}
/**
* Identify capability gaps from denied/pending capability requests.
*/
private async getCapabilityGaps(teamId: string) {
const results = await this.db
.select({
tool: teamCapabilityRequests.capabilityName,
requestCount: sql<number>`count(*)`,
})
.from(teamCapabilityRequests)
.where(and(
eq(teamCapabilityRequests.teamId, teamId),
sql`${teamCapabilityRequests.status} IN ('pending', 'rejected')`,
))
.groupBy(teamCapabilityRequests.capabilityName)
.orderBy(desc(sql`count(*)`))
.limit(10);
return results.map((r) => ({
tool: r.tool,
requestCount: Number(r.requestCount),
suggestion: `Install ${r.tool} connector or add to allowed tools`,
}));
}
/**
* Compute performance trends from audit log.
* - correctionRate: fraction of actions that were corrections/rejections
* - correctionTrend: difference between this week and last week correction rates
* - avgResponseTime: average time between job creation and completion (seconds)
*/
private async getPerformanceTrends(teamId: string) {
const now = new Date();
const oneWeekAgo = new Date(now.getTime() - 7 * 24 * 60 * 60 * 1000);
const twoWeeksAgo = new Date(now.getTime() - 14 * 24 * 60 * 60 * 1000);
// This week's correction rate
const [thisWeekTotal] = await this.db
.select({ count: sql<number>`count(*)` })
.from(agentAuditLog)
.where(and(
eq(agentAuditLog.teamId, teamId),
gte(agentAuditLog.createdAt, oneWeekAgo),
));
const [thisWeekRejected] = await this.db
.select({ count: sql<number>`count(*)` })
.from(agentAuditLog)
.where(and(
eq(agentAuditLog.teamId, teamId),
gte(agentAuditLog.createdAt, oneWeekAgo),
eq(agentAuditLog.approved, false),
));
// Last week's correction rate
const [lastWeekTotal] = await this.db
.select({ count: sql<number>`count(*)` })
.from(agentAuditLog)
.where(and(
eq(agentAuditLog.teamId, teamId),
gte(agentAuditLog.createdAt, twoWeeksAgo),
lt(agentAuditLog.createdAt, oneWeekAgo),
));
const [lastWeekRejected] = await this.db
.select({ count: sql<number>`count(*)` })
.from(agentAuditLog)
.where(and(
eq(agentAuditLog.teamId, teamId),
gte(agentAuditLog.createdAt, twoWeeksAgo),
lt(agentAuditLog.createdAt, oneWeekAgo),
eq(agentAuditLog.approved, false),
));
const thisWeekRate = Number(thisWeekTotal?.count) > 0
? Number(thisWeekRejected?.count ?? 0) / Number(thisWeekTotal.count)
: 0;
const lastWeekRate = Number(lastWeekTotal?.count) > 0
? Number(lastWeekRejected?.count ?? 0) / Number(lastWeekTotal.count)
: 0;
// Average response time from completed jobs
const [avgTime] = await this.db
.select({
avgSeconds: sql<number>`coalesce(avg(extract(epoch from (${agentJobs.completedAt} - ${agentJobs.createdAt}))), 0)`,
})
.from(agentJobs)
.where(and(
eq(agentJobs.teamId, teamId),
eq(agentJobs.status, 'completed'),
sql`${agentJobs.completedAt} IS NOT NULL`,
));
return {
correctionRate: Math.round(thisWeekRate * 100) / 100,
correctionTrend: Math.round((thisWeekRate - lastWeekRate) * 100) / 100,
avgResponseTime: Math.round(Number(avgTime?.avgSeconds ?? 0) * 10) / 10,
};
}
}

View File

@@ -1,74 +0,0 @@
import { eq, and, desc, isNull } from 'drizzle-orm';
import { agentAuditLog } from '../db/schema.js';
import type { Db } from '../db/connection.js';
export class AuditService {
constructor(private db: Db) {}
async log(entry: {
userId: string;
teamId?: string;
agentName: string;
actionType: string;
description: string;
beforeState?: Record<string, unknown>;
afterState?: Record<string, unknown>;
requiresApproval?: boolean;
}) {
const [created] = await this.db.insert(agentAuditLog).values({
userId: entry.userId,
teamId: entry.teamId ?? null,
agentName: entry.agentName,
actionType: entry.actionType,
description: entry.description,
beforeState: entry.beforeState ?? null,
afterState: entry.afterState ?? null,
requiresApproval: entry.requiresApproval ?? false,
}).returning();
return created;
}
async list(teamId: string, filters?: { actionType?: string; agentName?: string }) {
const conditions = [eq(agentAuditLog.teamId, teamId)];
if (filters?.actionType) conditions.push(eq(agentAuditLog.actionType, filters.actionType));
if (filters?.agentName) conditions.push(eq(agentAuditLog.agentName, filters.agentName));
return this.db.select().from(agentAuditLog)
.where(and(...conditions))
.orderBy(desc(agentAuditLog.createdAt))
.limit(100);
}
async getById(id: string) {
const [entry] = await this.db.select().from(agentAuditLog)
.where(eq(agentAuditLog.id, id))
.limit(1);
return entry ?? null;
}
async approve(entryId: string, approvedBy: string) {
const [updated] = await this.db.update(agentAuditLog)
.set({ approved: true, approvedBy })
.where(eq(agentAuditLog.id, entryId))
.returning();
return updated ?? null;
}
async reject(entryId: string, approvedBy: string) {
const [updated] = await this.db.update(agentAuditLog)
.set({ approved: false, approvedBy })
.where(eq(agentAuditLog.id, entryId))
.returning();
return updated ?? null;
}
async getPendingApprovals(teamId: string) {
return this.db.select().from(agentAuditLog)
.where(and(
eq(agentAuditLog.teamId, teamId),
eq(agentAuditLog.requiresApproval, true),
isNull(agentAuditLog.approved),
))
.orderBy(desc(agentAuditLog.createdAt));
}
}

View File

@@ -1,90 +0,0 @@
import { eq, and } from 'drizzle-orm';
import cronParser from 'cron-parser';
const { parseExpression } = cronParser;
import { cronSchedules } from '../db/schema.js';
import type { Db } from '../db/connection.js';
import { scheduledJobTypeSchema } from '@waggle/shared';
export function getNextRunAt(cronExpr: string): Date {
const interval = parseExpression(cronExpr);
return interval.next().toDate();
}
export class CronService {
constructor(private db: Db) {}
async create(
teamId: string,
userId: string,
data: { name: string; cronExpr: string; jobType: string; jobConfig?: Record<string, unknown> },
) {
// Validate cron expression by parsing it
const nextRunAt = getNextRunAt(data.cronExpr);
const jobType = scheduledJobTypeSchema.safeParse(data.jobType);
if (!jobType.success) {
throw new Error(`Unsupported scheduled job type: ${data.jobType}`);
}
const [schedule] = await this.db.insert(cronSchedules).values({
teamId,
createdBy: userId,
name: data.name,
cronExpr: data.cronExpr,
jobType: jobType.data,
jobConfig: data.jobConfig ?? {},
enabled: true,
nextRunAt,
}).returning();
return schedule;
}
async list(teamId: string) {
return this.db.select().from(cronSchedules)
.where(eq(cronSchedules.teamId, teamId));
}
async getById(id: string) {
const [schedule] = await this.db.select().from(cronSchedules)
.where(eq(cronSchedules.id, id));
return schedule ?? null;
}
async update(teamId: string, id: string, data: { name?: string; cronExpr?: string; enabled?: boolean; jobConfig?: Record<string, unknown> }) {
const updates: Record<string, unknown> = {};
if (data.name !== undefined) updates.name = data.name;
if (data.enabled !== undefined) updates.enabled = data.enabled;
if (data.jobConfig !== undefined) updates.jobConfig = data.jobConfig;
if (data.cronExpr !== undefined) {
updates.cronExpr = data.cronExpr;
updates.nextRunAt = getNextRunAt(data.cronExpr);
}
if (Object.keys(updates).length === 0) return null;
const [updated] = await this.db.update(cronSchedules)
.set(updates)
.where(and(
eq(cronSchedules.id, id),
eq(cronSchedules.teamId, teamId),
))
.returning();
return updated ?? null;
}
async markRun(id: string) {
const schedule = await this.getById(id);
if (!schedule) return null;
const now = new Date();
const nextRunAt = getNextRunAt(schedule.cronExpr);
const [updated] = await this.db.update(cronSchedules)
.set({ lastRunAt: now, nextRunAt })
.where(eq(cronSchedules.id, id))
.returning();
return updated ?? null;
}
}

View File

@@ -1,103 +0,0 @@
import { Queue } from 'bullmq';
import { eq, desc } from 'drizzle-orm';
import { agentJobs } from '../db/schema.js';
import type { Db } from '../db/connection.js';
export class JobService {
private queue: Queue;
constructor(private db: Db, redisUrl: string, queueName = 'waggle-jobs') {
const url = new URL(redisUrl);
this.queue = new Queue(queueName, {
connection: {
host: url.hostname,
port: parseInt(url.port || '6379'),
},
});
}
async createJob(
teamId: string,
userId: string,
jobType: string,
input: Record<string, unknown>,
jobId?: string,
) {
const [created] = await this.db.insert(agentJobs).values({
...(jobId ? { id: jobId } : {}),
teamId,
userId,
jobType,
status: 'queued',
input,
}).onConflictDoNothing({ target: agentJobs.id }).returning();
const job = created ?? (jobId ? await this.getJob(jobId) : null);
if (!job) throw new Error('Failed to create job');
if (job.teamId !== teamId || job.userId !== userId || job.jobType !== jobType) {
throw new Error('Job idempotency key collision');
}
await this.queue.add(job.jobType, {
jobId: job.id,
teamId: job.teamId,
userId: job.userId,
jobType: job.jobType,
input: job.input,
}, { jobId: job.id });
return job;
}
async getJob(jobId: string) {
const [job] = await this.db.select().from(agentJobs).where(eq(agentJobs.id, jobId));
return job ?? null;
}
async listByTeam(teamId: string, limit = 50) {
return this.db.select().from(agentJobs)
.where(eq(agentJobs.teamId, teamId))
.orderBy(desc(agentJobs.createdAt))
.limit(Math.min(limit, 100));
}
async updateJobStatus(jobId: string, status: string, output?: Record<string, unknown>) {
const updates: Record<string, unknown> = { status };
if (status === 'running') updates.startedAt = new Date();
if (status === 'completed' || status === 'failed') {
updates.completedAt = new Date();
if (output) updates.output = output;
}
const [updated] = await this.db.update(agentJobs)
.set(updates)
.where(eq(agentJobs.id, jobId))
.returning();
return updated;
}
async cancelJob(jobId: string) {
// Update DB status
const updated = await this.updateJobStatus(jobId, 'cancelled');
// Try to remove from BullMQ queue
try {
const bullJob = await this.queue.getJob(jobId);
if (bullJob) {
const state = await bullJob.getState();
if (state === 'waiting' || state === 'delayed') {
await bullJob.remove();
} else if (state === 'active') {
await bullJob.moveToFailed(new Error('Cancelled by user'), 'cancelled', true);
}
}
} catch {
// Queue removal failed — DB status is still updated
}
return updated;
}
async close() {
await this.queue.close();
}
}

View File

@@ -1,168 +0,0 @@
import { eq, and, or, ilike, inArray } from 'drizzle-orm';
import { teamEntities, teamRelations } from '../db/schema.js';
import type { Db } from '../db/connection.js';
export interface EntityFilters {
entityType?: string;
search?: string;
}
export class KnowledgeService {
constructor(private db: Db) {}
async createEntity(
teamId: string,
userId: string,
data: {
entityType: string;
name: string;
properties?: Record<string, unknown>;
validFrom?: string;
validTo?: string;
},
) {
const values: typeof teamEntities.$inferInsert = {
teamId,
entityType: data.entityType,
name: data.name,
properties: data.properties ?? {},
sharedBy: userId,
};
if (data.validFrom) values.validFrom = new Date(data.validFrom);
if (data.validTo) values.validTo = new Date(data.validTo);
const [entity] = await this.db.insert(teamEntities).values(values).returning();
return entity;
}
async listEntities(teamId: string, filters?: EntityFilters) {
const conditions = [eq(teamEntities.teamId, teamId)];
if (filters?.entityType) {
conditions.push(eq(teamEntities.entityType, filters.entityType));
}
if (filters?.search) {
conditions.push(ilike(teamEntities.name, `%${filters.search}%`));
}
return this.db
.select()
.from(teamEntities)
.where(and(...conditions));
}
async getEntity(entityId: string) {
const [entity] = await this.db
.select()
.from(teamEntities)
.where(eq(teamEntities.id, entityId))
.limit(1);
return entity ?? null;
}
async createRelation(
teamId: string,
data: {
sourceId: string;
targetId: string;
relationType: string;
confidence?: number;
properties?: Record<string, unknown>;
},
) {
const endpointIds = [...new Set([data.sourceId, data.targetId])];
const ownedEndpoints = await this.db
.select({ id: teamEntities.id })
.from(teamEntities)
.where(and(
eq(teamEntities.teamId, teamId),
inArray(teamEntities.id, endpointIds),
));
if (ownedEndpoints.length !== endpointIds.length) return null;
const [relation] = await this.db.insert(teamRelations).values({
teamId,
sourceId: data.sourceId,
targetId: data.targetId,
relationType: data.relationType,
confidence: data.confidence ?? 1.0,
properties: data.properties ?? {},
}).returning();
return relation;
}
async queryGraph(
teamId: string,
startEntityId: string,
depth: number = 2,
relationTypes?: string[],
) {
const [startEntity] = await this.db
.select()
.from(teamEntities)
.where(and(
eq(teamEntities.id, startEntityId),
eq(teamEntities.teamId, teamId),
))
.limit(1);
if (!startEntity) return null;
const visited = new Set<string>([startEntityId]);
const resultEntities: Array<typeof teamEntities.$inferSelect> = [startEntity];
const resultRelations: Array<typeof teamRelations.$inferSelect> = [];
let frontier = [startEntityId];
for (let d = 0; d < depth && frontier.length > 0; d++) {
// Find relations connected to frontier entities
const rels = await this.db
.select()
.from(teamRelations)
.where(
and(
eq(teamRelations.teamId, teamId),
or(
inArray(teamRelations.sourceId, frontier),
inArray(teamRelations.targetId, frontier),
),
),
);
// Apply relationTypes filter if provided
const filteredRels = relationTypes
? rels.filter((r) => relationTypes.includes(r.relationType))
: rels;
const nextFrontier: string[] = [];
for (const rel of filteredRels) {
resultRelations.push(rel);
for (const id of [rel.sourceId, rel.targetId]) {
if (!visited.has(id)) {
visited.add(id);
nextFrontier.push(id);
}
}
}
if (nextFrontier.length > 0) {
const entities = await this.db
.select()
.from(teamEntities)
.where(
and(
eq(teamEntities.teamId, teamId),
inArray(teamEntities.id, nextFrontier),
),
);
resultEntities.push(...entities);
}
frontier = nextFrontier;
}
return {
entities: resultEntities,
relations: resultRelations,
};
}
}

View File

@@ -1,119 +0,0 @@
import { eq, and, desc, sql } from 'drizzle-orm';
import { messages, teamEntities, tasks } from '../db/schema.js';
import type { Db } from '../db/connection.js';
import type { HiveQuery, HiveQueryResult } from '@waggle/waggle-dance';
import type Redis from 'ioredis';
export interface MessageFilters {
type?: string;
subtype?: string;
}
export class MessageService {
constructor(private db: Db) {}
async send(
teamId: string,
senderId: string,
data: {
type: string;
subtype: string;
content: Record<string, unknown>;
referenceId?: string;
routing?: Array<{ userId: string; reason: string }>;
},
redis?: Redis,
) {
const [message] = await this.db.insert(messages).values({
teamId,
senderId,
type: data.type,
subtype: data.subtype,
content: data.content,
referenceId: data.referenceId ?? null,
routing: data.routing ?? null,
}).returning();
// Publish to Redis for real-time delivery
if (redis) {
await redis.publish(`team:${teamId}:waggle`, JSON.stringify(message));
}
return message;
}
async list(teamId: string, filters?: MessageFilters) {
const conditions = [eq(messages.teamId, teamId)];
if (filters?.type) {
conditions.push(eq(messages.type, filters.type));
}
if (filters?.subtype) {
conditions.push(eq(messages.subtype, filters.subtype));
}
return this.db
.select()
.from(messages)
.where(and(...conditions))
.orderBy(desc(messages.createdAt));
}
async checkHive(teamId: string, query: HiveQuery): Promise<HiveQueryResult> {
const searchTerm = `%${query.topic}%`;
// Search team_entities by name or entityType matching the topic
const entities = await this.db
.select({
id: teamEntities.id,
name: teamEntities.name,
entityType: teamEntities.entityType,
properties: teamEntities.properties,
})
.from(teamEntities)
.where(
and(
eq(teamEntities.teamId, teamId),
sql`(${teamEntities.name} ILIKE ${searchTerm} OR ${teamEntities.entityType} ILIKE ${searchTerm})`,
),
)
.limit(10);
// Search tasks by title or description matching the topic
const relatedTasks = await this.db
.select({
id: tasks.id,
title: tasks.title,
status: tasks.status,
createdBy: tasks.createdBy,
})
.from(tasks)
.where(
and(
eq(tasks.teamId, teamId),
sql`(${tasks.title} ILIKE ${searchTerm} OR ${tasks.description} ILIKE ${searchTerm})`,
),
)
.limit(10);
// Search recent broadcast messages
const relatedMessages = await this.db
.select({
id: messages.id,
type: messages.type,
subtype: messages.subtype,
content: messages.content,
})
.from(messages)
.where(
and(
eq(messages.teamId, teamId),
eq(messages.type, 'broadcast'),
),
)
.orderBy(desc(messages.createdAt))
.limit(10);
return { entities, relatedTasks, relatedMessages };
}
}

View File

@@ -1,102 +0,0 @@
import { eq, and, desc } from 'drizzle-orm';
import { proactivePatterns, suggestionsLog } from '../db/schema.js';
import type { Db } from '../db/connection.js';
import { MAX_SUGGESTIONS_PER_INTERACTION } from '@waggle/shared';
import { BUILT_IN_PATTERNS } from '../proactive/patterns.js';
export class ProactiveService {
constructor(private db: Db) {}
async ensurePatternsSeeded() {
const existing = await this.db.select().from(proactivePatterns);
if (existing.length === 0) {
for (const p of BUILT_IN_PATTERNS) {
await this.db.insert(proactivePatterns).values({
name: p.name,
trigger: { condition: p.triggerCondition },
suggestionType: p.suggestionType,
template: p.template,
});
}
}
}
async evaluate(userId: string, jobContext: Record<string, unknown>) {
// Check if user already has max pending suggestions
const pending = await this.db.select().from(suggestionsLog)
.where(and(
eq(suggestionsLog.userId, userId),
eq(suggestionsLog.status, 'pending'),
));
if (pending.length >= MAX_SUGGESTIONS_PER_INTERACTION) return null;
// Get active patterns
const patterns = await this.db.select().from(proactivePatterns)
.where(eq(proactivePatterns.enabled, true));
for (const pattern of patterns) {
const shouldTrigger = this.matchPattern(pattern, jobContext);
if (!shouldTrigger) continue;
// Check if already dismissed for this pattern
const dismissed = await this.db.select().from(suggestionsLog)
.where(and(
eq(suggestionsLog.userId, userId),
eq(suggestionsLog.patternId, pattern.id),
eq(suggestionsLog.status, 'dismissed'),
));
if (dismissed.length > 0) continue;
// Create suggestion
const [suggestion] = await this.db.insert(suggestionsLog).values({
userId,
patternId: pattern.id,
context: jobContext,
status: 'pending',
}).returning();
return { ...suggestion, pattern };
}
return null;
}
private matchPattern(
pattern: { suggestionType: string },
context: Record<string, unknown>,
): boolean {
const triggerType = pattern.suggestionType;
if (triggerType === 'cron' && context.repeatCount && (context.repeatCount as number) >= 3) return true;
if (triggerType === 'dashboard' && context.hasData) return true;
if (triggerType === 'share' && context.relevantUsers) return true;
if (triggerType === 'upgrade' && context.expensiveModel) return true;
if (triggerType === 'skill' && context.manualSteps) return true;
return false;
}
async listPending(userId: string) {
return this.db.select().from(suggestionsLog)
.where(and(
eq(suggestionsLog.userId, userId),
eq(suggestionsLog.status, 'pending'),
))
.orderBy(desc(suggestionsLog.createdAt));
}
async updateStatus(
suggestionId: string,
userId: string,
status: 'accepted' | 'dismissed' | 'snoozed',
) {
const [updated] = await this.db.update(suggestionsLog)
.set({ status })
.where(and(
eq(suggestionsLog.id, suggestionId),
eq(suggestionsLog.userId, userId),
))
.returning();
return updated ?? null;
}
}

View File

@@ -1,89 +0,0 @@
import { eq, and } from 'drizzle-orm';
import { teamResources } from '../db/schema.js';
import type { Db } from '../db/connection.js';
export class ResourceService {
constructor(private db: Db) {}
async share(
teamId: string,
userId: string,
data: {
resourceType: string;
name: string;
description?: string;
config: Record<string, unknown>;
},
) {
const [resource] = await this.db.insert(teamResources).values({
teamId,
resourceType: data.resourceType,
name: data.name,
description: data.description ?? null,
config: data.config,
sharedBy: userId,
rating: 0,
useCount: 0,
}).returning();
return resource;
}
async list(teamId: string, resourceType?: string) {
const conditions = [eq(teamResources.teamId, teamId)];
if (resourceType) {
conditions.push(eq(teamResources.resourceType, resourceType));
}
return this.db
.select()
.from(teamResources)
.where(and(...conditions));
}
async rate(teamId: string, resourceId: string, rating: number) {
const [resource] = await this.db
.select()
.from(teamResources)
.where(and(
eq(teamResources.id, resourceId),
eq(teamResources.teamId, teamId),
))
.limit(1);
if (!resource) return null;
const newRating = resource.useCount > 0
? (resource.rating * resource.useCount + rating) / (resource.useCount + 1)
: rating;
const [updated] = await this.db.update(teamResources)
.set({ rating: newRating })
.where(and(
eq(teamResources.id, resourceId),
eq(teamResources.teamId, teamId),
))
.returning();
return updated;
}
async incrementUseCount(teamId: string, resourceId: string) {
const [resource] = await this.db
.select()
.from(teamResources)
.where(and(
eq(teamResources.id, resourceId),
eq(teamResources.teamId, teamId),
))
.limit(1);
if (!resource) return null;
const [updated] = await this.db.update(teamResources)
.set({ useCount: resource.useCount + 1 })
.where(and(
eq(teamResources.id, resourceId),
eq(teamResources.teamId, teamId),
))
.returning();
return updated;
}
}

View File

@@ -1,91 +0,0 @@
import { eq, and } from 'drizzle-orm';
import { tasks } from '../db/schema.js';
import type { Db } from '../db/connection.js';
export interface TaskFilters {
status?: string;
assignee?: string;
priority?: string;
}
export class TaskService {
constructor(private db: Db) {}
async create(
teamId: string,
userId: string,
data: { title: string; description?: string; priority?: string; parentTaskId?: string },
) {
const [task] = await this.db.insert(tasks).values({
teamId,
title: data.title,
description: data.description,
priority: data.priority ?? 'normal',
createdBy: userId,
parentTaskId: data.parentTaskId,
}).returning();
return task;
}
async list(teamId: string, filters?: TaskFilters) {
const conditions = [eq(tasks.teamId, teamId)];
if (filters?.status) {
conditions.push(eq(tasks.status, filters.status));
}
if (filters?.assignee) {
conditions.push(eq(tasks.assignedTo, filters.assignee));
}
if (filters?.priority) {
conditions.push(eq(tasks.priority, filters.priority));
}
return this.db
.select()
.from(tasks)
.where(and(...conditions));
}
async get(taskId: string) {
const [task] = await this.db
.select()
.from(tasks)
.where(eq(tasks.id, taskId))
.limit(1);
return task ?? null;
}
async update(
taskId: string,
data: {
title?: string;
description?: string;
status?: string;
priority?: string;
assignedTo?: string | null;
},
) {
const setData: Record<string, unknown> = { updatedAt: new Date() };
if (data.title !== undefined) setData.title = data.title;
if (data.description !== undefined) setData.description = data.description;
if (data.status !== undefined) setData.status = data.status;
if (data.priority !== undefined) setData.priority = data.priority;
if (data.assignedTo !== undefined) setData.assignedTo = data.assignedTo;
const [updated] = await this.db
.update(tasks)
.set(setData)
.where(eq(tasks.id, taskId))
.returning();
return updated ?? null;
}
async claim(taskId: string, userId: string) {
const [updated] = await this.db
.update(tasks)
.set({ assignedTo: userId, status: 'claimed', updatedAt: new Date() })
.where(eq(tasks.id, taskId))
.returning();
return updated ?? null;
}
}

View File

@@ -1,379 +0,0 @@
import { eq, and, desc } from 'drizzle-orm';
import { RISK_LEVELS, riskRank, type RiskLevel } from '@waggle/shared';
import {
teamCapabilityPolicies,
teamCapabilityOverrides,
teamCapabilityRequests,
} from '../db/schema.js';
import type { DbExecutor } from '../db/connection.js';
export interface EffectivePermissions {
role: string;
allowedSources: string[];
blockedTools: string[];
approvalThreshold: string;
overrides: Map<string, 'approved' | 'blocked'>;
}
export type PermissionResult =
| 'allowed'
| 'blocked'
| 'needs_approval'
| 'source_not_allowed';
/**
* Rank a governance risk string on the canonical scale (P7/D15 A2b). The
* governance domain adds a 'none' tier (below 'low') that the canonical set
* doesn't have. Anything else falls back to canonical riskRank, so 'critical'
* (rank 3) correctly outranks 'low' (0) — the previous local map omitted
* 'critical', so `?? 0` sorted a critical risk BELOW low (a silent RBAC defect).
*/
function governanceRiskRank(level: string): number {
if (level === 'none') return -1;
return (RISK_LEVELS as readonly string[]).includes(level)
? riskRank(level as RiskLevel)
: -1;
}
/**
* Check if a given risk level exceeds the threshold.
* Threshold 'none' means nothing triggers approval.
*/
export function riskExceedsThreshold(risk: string, threshold: string): boolean {
if (threshold === 'none') return false;
return governanceRiskRank(risk) > governanceRiskRank(threshold);
}
/**
* Resolve permission for a single capability against effective permissions.
*
* Resolution order:
* 1. Check overrides — if override exists, return its decision immediately
* 2. Check role policy (source allowed? tool blocked?)
* 3. If policy allows but risk exceeds threshold → needs_approval
* 4. Otherwise → allowed
*/
export function resolvePermission(
perms: EffectivePermissions,
capabilityName: string,
capabilityType: string,
risk: string = 'low',
): PermissionResult {
// 1. Override wins
const override = perms.overrides.get(capabilityName);
if (override === 'approved') return 'allowed';
if (override === 'blocked') return 'blocked';
// 2. Blocked tool check
if (perms.blockedTools.includes(capabilityName)) return 'blocked';
// 3. Source allowed check
if (!perms.allowedSources.includes(capabilityType)) return 'source_not_allowed';
// 4. Risk threshold check
if (riskExceedsThreshold(risk, perms.approvalThreshold)) return 'needs_approval';
return 'allowed';
}
/**
* Filter a list of capabilities by permissions, returning only those allowed or needing approval.
*/
export function filterByPermissions(
perms: EffectivePermissions,
capabilities: Array<{ name: string; type: string; risk?: string }>,
): Array<{ name: string; type: string; risk?: string; result: PermissionResult }> {
return capabilities.map((cap) => ({
...cap,
result: resolvePermission(perms, cap.name, cap.type, cap.risk ?? 'low'),
}));
}
export interface DefaultPolicy {
role: string;
allowedSources: string[];
blockedTools: string[];
approvalThreshold: string;
}
/**
* Returns the 3 default role policies for a new team.
*/
export function getDefaultPolicies(): DefaultPolicy[] {
return [
{
role: 'owner',
allowedSources: ['native', 'skill', 'plugin', 'mcp'],
blockedTools: [],
approvalThreshold: 'none',
},
{
role: 'admin',
allowedSources: ['native', 'skill', 'plugin', 'mcp'],
blockedTools: [],
approvalThreshold: 'none',
},
{
role: 'member',
allowedSources: ['native', 'skill'],
blockedTools: ['bash', 'delete_skill'],
approvalThreshold: 'medium',
},
];
}
export class TeamCapabilityGovernance {
constructor(private db: DbExecutor) {}
/**
* Get effective permissions for a role in a team, including overrides.
*/
async getEffectivePermissions(teamId: string, role: string): Promise<EffectivePermissions> {
// Get role policy
const [policy] = await this.db
.select()
.from(teamCapabilityPolicies)
.where(and(
eq(teamCapabilityPolicies.teamId, teamId),
eq(teamCapabilityPolicies.role, role),
))
.limit(1);
// Get overrides for this team
const overrideRows = await this.db
.select()
.from(teamCapabilityOverrides)
.where(eq(teamCapabilityOverrides.teamId, teamId));
const overrides = new Map<string, 'approved' | 'blocked'>();
for (const row of overrideRows) {
overrides.set(row.capabilityName, row.decision as 'approved' | 'blocked');
}
if (!policy) {
// Fallback: no policy found, restrictive defaults
return {
role,
allowedSources: [],
blockedTools: [],
approvalThreshold: 'none',
overrides,
};
}
return {
role,
allowedSources: policy.allowedSources as string[],
blockedTools: policy.blockedTools as string[],
approvalThreshold: policy.approvalThreshold,
overrides,
};
}
async listPolicies(teamId: string) {
return this.db
.select()
.from(teamCapabilityPolicies)
.where(eq(teamCapabilityPolicies.teamId, teamId));
}
async upsertPolicy(
teamId: string,
role: string,
data: {
allowedSources?: string[];
blockedTools?: string[];
approvalThreshold?: string;
},
updatedBy: string,
) {
const [existing] = await this.db
.select()
.from(teamCapabilityPolicies)
.where(and(
eq(teamCapabilityPolicies.teamId, teamId),
eq(teamCapabilityPolicies.role, role),
))
.limit(1);
if (existing) {
const [updated] = await this.db
.update(teamCapabilityPolicies)
.set({
...(data.allowedSources !== undefined && { allowedSources: data.allowedSources }),
...(data.blockedTools !== undefined && { blockedTools: data.blockedTools }),
...(data.approvalThreshold !== undefined && { approvalThreshold: data.approvalThreshold }),
updatedBy,
updatedAt: new Date(),
})
.where(eq(teamCapabilityPolicies.id, existing.id))
.returning();
return updated;
}
const defaults = getDefaultPolicies().find((p) => p.role === role);
const [created] = await this.db
.insert(teamCapabilityPolicies)
.values({
teamId,
role,
allowedSources: data.allowedSources ?? defaults?.allowedSources ?? [],
blockedTools: data.blockedTools ?? defaults?.blockedTools ?? [],
approvalThreshold: data.approvalThreshold ?? defaults?.approvalThreshold ?? 'none',
updatedBy,
})
.returning();
return created;
}
async seedDefaultPolicies(teamId: string, seedBy: string) {
const defaults = getDefaultPolicies();
const results = [];
for (const policy of defaults) {
const [row] = await this.db
.insert(teamCapabilityPolicies)
.values({
teamId,
role: policy.role,
allowedSources: policy.allowedSources,
blockedTools: policy.blockedTools,
approvalThreshold: policy.approvalThreshold,
updatedBy: seedBy,
})
.returning();
results.push(row);
}
return results;
}
// --- Overrides ---
async listOverrides(teamId: string) {
return this.db
.select()
.from(teamCapabilityOverrides)
.where(eq(teamCapabilityOverrides.teamId, teamId))
.orderBy(desc(teamCapabilityOverrides.createdAt));
}
async createOverride(
teamId: string,
data: {
capabilityName: string;
capabilityType: string;
decision: 'approved' | 'blocked';
reason?: string;
},
decidedBy: string,
) {
const [row] = await this.db
.insert(teamCapabilityOverrides)
.values({
teamId,
capabilityName: data.capabilityName,
capabilityType: data.capabilityType,
decision: data.decision,
reason: data.reason ?? '',
decidedBy,
})
.returning();
return row;
}
async deleteOverride(teamId: string, overrideId: string) {
const [deleted] = await this.db
.delete(teamCapabilityOverrides)
.where(and(
eq(teamCapabilityOverrides.teamId, teamId),
eq(teamCapabilityOverrides.id, overrideId),
))
.returning();
return deleted ?? null;
}
// --- Requests ---
async listRequests(teamId: string, status?: string) {
const conditions = [eq(teamCapabilityRequests.teamId, teamId)];
if (status) {
conditions.push(eq(teamCapabilityRequests.status, status));
}
return this.db
.select()
.from(teamCapabilityRequests)
.where(and(...conditions))
.orderBy(desc(teamCapabilityRequests.createdAt));
}
async submitRequest(
teamId: string,
requestedBy: string,
data: {
capabilityName: string;
capabilityType: string;
justification: string;
},
): Promise<{ duplicate: true } | { duplicate: false; request: typeof teamCapabilityRequests.$inferSelect }> {
// Duplicate check: pending request for same capability by same user
const [existing] = await this.db
.select()
.from(teamCapabilityRequests)
.where(and(
eq(teamCapabilityRequests.teamId, teamId),
eq(teamCapabilityRequests.requestedBy, requestedBy),
eq(teamCapabilityRequests.capabilityName, data.capabilityName),
eq(teamCapabilityRequests.status, 'pending'),
))
.limit(1);
if (existing) return { duplicate: true };
const [request] = await this.db
.insert(teamCapabilityRequests)
.values({
teamId,
requestedBy,
capabilityName: data.capabilityName,
capabilityType: data.capabilityType,
justification: data.justification,
})
.returning();
return { duplicate: false, request };
}
async getRequest(teamId: string, requestId: string) {
const [row] = await this.db
.select()
.from(teamCapabilityRequests)
.where(and(
eq(teamCapabilityRequests.teamId, teamId),
eq(teamCapabilityRequests.id, requestId),
))
.limit(1);
return row ?? null;
}
async decideRequest(
teamId: string,
requestId: string,
decidedBy: string,
decision: 'approved' | 'rejected',
reason?: string,
) {
const [updated] = await this.db
.update(teamCapabilityRequests)
.set({
status: decision,
decidedBy,
decisionReason: reason ?? null,
decidedAt: new Date(),
})
.where(and(
eq(teamCapabilityRequests.teamId, teamId),
eq(teamCapabilityRequests.id, requestId),
))
.returning();
return updated ?? null;
}
}

View File

@@ -1,139 +0,0 @@
import { eq, and, sql } from 'drizzle-orm';
import { teams, teamMembers, users } from '../db/schema.js';
import type { Db } from '../db/connection.js';
import { TeamCapabilityGovernance } from './team-capability-governance.js';
export class TeamService {
constructor(private db: Db) {}
async create(ownerId: string, data: { name: string; slug: string }) {
return this.db.transaction(async (tx) => {
const [team] = await tx.insert(teams).values({
name: data.name,
slug: data.slug,
ownerId,
}).returning();
await tx.insert(teamMembers).values({
teamId: team.id,
userId: ownerId,
role: 'owner',
});
// Seed default capability policies
const governance = new TeamCapabilityGovernance(tx);
await governance.seedDefaultPolicies(team.id, ownerId);
return team;
});
}
async getBySlug(slug: string) {
const [team] = await this.db.select().from(teams).where(eq(teams.slug, slug)).limit(1);
return team ?? null;
}
async listForUser(userId: string) {
const rows = await this.db
.select({
id: teams.id,
name: teams.name,
slug: teams.slug,
ownerId: teams.ownerId,
createdAt: teams.createdAt,
role: teamMembers.role,
})
.from(teamMembers)
.innerJoin(teams, eq(teamMembers.teamId, teams.id))
.where(eq(teamMembers.userId, userId));
return rows;
}
async update(teamId: string, data: { name: string }) {
const [updated] = await this.db
.update(teams)
.set({ name: data.name })
.where(eq(teams.id, teamId))
.returning();
return updated ?? null;
}
async addMember(teamId: string, userId: string, role: 'admin' | 'member') {
const [member] = await this.db.insert(teamMembers).values({
teamId,
userId,
role,
}).returning();
return member;
}
async removeMember(teamId: string, userId: string) {
// Prevent removing the owner
const membership = await this.getMembership(teamId, userId);
if (!membership) return false;
if (membership.role === 'owner') {
throw new Error('Cannot remove the team owner');
}
await this.db
.delete(teamMembers)
.where(and(eq(teamMembers.teamId, teamId), eq(teamMembers.userId, userId)));
return true;
}
async updateMember(
teamId: string,
userId: string,
data: { role?: 'admin' | 'member'; roleDescription?: string; interests?: string[] },
) {
if (data.role !== undefined) {
const membership = await this.getMembership(teamId, userId);
if (!membership) return null;
if (membership.role === 'owner') {
throw new Error('Cannot change the team owner role');
}
}
const setData: Record<string, unknown> = {};
if (data.role !== undefined) setData.role = data.role;
if (data.roleDescription !== undefined) setData.roleDescription = data.roleDescription;
if (data.interests !== undefined) setData.interests = data.interests;
if (Object.keys(setData).length === 0) return null;
const [updated] = await this.db
.update(teamMembers)
.set(setData)
.where(and(eq(teamMembers.teamId, teamId), eq(teamMembers.userId, userId)))
.returning();
return updated ?? null;
}
async getMembership(teamId: string, userId: string) {
const [membership] = await this.db
.select()
.from(teamMembers)
.where(and(eq(teamMembers.teamId, teamId), eq(teamMembers.userId, userId)))
.limit(1);
return membership ?? null;
}
async getMembers(teamId: string) {
const rows = await this.db
.select({
userId: teamMembers.userId,
role: teamMembers.role,
roleDescription: teamMembers.roleDescription,
interests: teamMembers.interests,
joinedAt: teamMembers.joinedAt,
displayName: users.displayName,
email: users.email,
avatarUrl: users.avatarUrl,
})
.from(teamMembers)
.innerJoin(users, eq(teamMembers.userId, users.id))
.where(eq(teamMembers.teamId, teamId));
return rows;
}
}

View File

@@ -1,59 +0,0 @@
import { eq } from 'drizzle-orm';
import { users } from '../db/schema.js';
import type { Db } from '../db/connection.js';
export interface ClerkUserData {
clerkId: string;
displayName: string;
email: string;
avatarUrl?: string | null;
}
export class UserService {
constructor(private db: Db) {}
async getByClerkId(clerkId: string) {
const [user] = await this.db.select().from(users).where(eq(users.clerkId, clerkId)).limit(1);
return user ?? null;
}
async getById(id: string) {
const [user] = await this.db.select().from(users).where(eq(users.id, id)).limit(1);
return user ?? null;
}
/**
* Create or update a user from Clerk JWT claims.
* Used by auth plugin for auto-provisioning on first auth,
* and by webhook for ongoing sync.
*/
async upsertFromClerk(data: ClerkUserData) {
const existing = await this.getByClerkId(data.clerkId);
if (existing) {
// Update display name / email / avatar if changed
await this.db.update(users)
.set({
displayName: data.displayName,
email: data.email,
avatarUrl: data.avatarUrl ?? null,
updatedAt: new Date(),
})
.where(eq(users.clerkId, data.clerkId));
// Return fresh copy
return (await this.getByClerkId(data.clerkId))!;
}
// Insert new user
const [created] = await this.db.insert(users)
.values({
clerkId: data.clerkId,
displayName: data.displayName,
email: data.email,
avatarUrl: data.avatarUrl ?? null,
})
.returning();
return created;
}
}