agent-relay 1.6.0 → 2.0.0

package/packages/cloud/dist/db/drizzle.js

@@ -0,0 +1,1286 @@
+/**
+ * Agent Relay Cloud - Drizzle Database Client
+ *
+ * Type-safe database access using Drizzle ORM.
+ * Use this instead of the raw pg client for new code.
+ */
+import { drizzle } from 'drizzle-orm/node-postgres';
+import { Pool } from 'pg';
+import { eq, and, or, sql, desc, lt, isNull, isNotNull, inArray } from 'drizzle-orm';
+import * as schema from './schema.js';
+import { getConfig } from '../config.js';
+import { DEFAULT_POOL_CONFIG } from './bulk-ingest.js';
+// Re-export schema for direct table access
+export * from './schema.js';
+// Initialize pool and drizzle lazily
+let pool = null;
+let drizzleDb = null;
+/**
+ * Get or create the connection pool with optimized settings.
+ * Pool configuration:
+ * - max: 20 connections (up from default 10)
+ * - idleTimeoutMillis: 30s (close idle connections)
+ * - connectionTimeoutMillis: 10s (fail fast on connection issues)
+ */
+function getPool() {
+    if (!pool) {
+        const config = getConfig();
+        pool = new Pool({
+            connectionString: config.databaseUrl,
+            ...DEFAULT_POOL_CONFIG,
+            // Allow SSL for cloud databases
+            ssl: config.databaseUrl?.includes('sslmode=require')
+                ? { rejectUnauthorized: false }
+                : undefined,
+        });
+        // Log pool errors (connection issues, etc.)
+        pool.on('error', (err) => {
+            console.error('[db] Pool error:', err.message);
+        });
+    }
+    return pool;
+}
+/**
+ * Get the raw connection pool for bulk operations.
+ * Use this for optimized bulk inserts that bypass the ORM.
+ */
+export function getRawPool() {
+    return getPool();
+}
+export function getDb() {
+    if (!drizzleDb) {
+        drizzleDb = drizzle(getPool(), { schema });
+    }
+    return drizzleDb;
+}
+export const userQueries = {
+    async findById(id) {
+        const db = getDb();
+        const result = await db.select().from(schema.users).where(eq(schema.users.id, id));
+        return result[0] ?? null;
+    },
+    async findByGithubId(githubId) {
+        const db = getDb();
+        const result = await db.select().from(schema.users).where(eq(schema.users.githubId, githubId));
+        return result[0] ?? null;
+    },
+    async findByGithubUsername(username) {
+        const db = getDb();
+        const result = await db.select().from(schema.users).where(eq(schema.users.githubUsername, username));
+        return result[0] ?? null;
+    },
+    async findByEmail(email) {
+        const db = getDb();
+        const result = await db.select().from(schema.users).where(eq(schema.users.email, email));
+        return result[0] ?? null;
+    },
+    async findByNangoConnectionId(connectionId) {
+        const db = getDb();
+        const result = await db
+            .select()
+            .from(schema.users)
+            .where(eq(schema.users.nangoConnectionId, connectionId));
+        return result[0] ?? null;
+    },
+    async findByIncomingConnectionId(connectionId) {
+        const db = getDb();
+        const result = await db.select().from(schema.users).where(eq(schema.users.incomingConnectionId, connectionId));
+        return result[0] ?? null;
+    },
+    async findByPlan(plan) {
+        const db = getDb();
+        const result = await db.select().from(schema.users).where(eq(schema.users.plan, plan));
+        return result;
+    },
+    async upsert(data) {
+        const db = getDb();
+        const result = await db
+            .insert(schema.users)
+            .values(data)
+            .onConflictDoUpdate({
+            target: schema.users.githubId,
+            set: {
+                githubUsername: data.githubUsername,
+                email: data.email,
+                avatarUrl: data.avatarUrl,
+                updatedAt: new Date(),
+            },
+        })
+            .returning();
+        return result[0];
+    },
+    async completeOnboarding(userId) {
+        const db = getDb();
+        await db
+            .update(schema.users)
+            .set({ onboardingCompletedAt: new Date(), updatedAt: new Date() })
+            .where(eq(schema.users.id, userId));
+    },
+    async update(id, data) {
+        const db = getDb();
+        await db
+            .update(schema.users)
+            .set({ ...data, updatedAt: new Date() })
+            .where(eq(schema.users.id, id));
+    },
+    async clearIncomingConnectionId(userId) {
+        const db = getDb();
+        await db
+            .update(schema.users)
+            .set({ incomingConnectionId: null, updatedAt: new Date() })
+            .where(eq(schema.users.id, userId));
+    },
+    async setPendingInstallationRequest(userId) {
+        const db = getDb();
+        await db
+            .update(schema.users)
+            .set({ pendingInstallationRequest: new Date(), updatedAt: new Date() })
+            .where(eq(schema.users.id, userId));
+    },
+    async clearPendingInstallationRequest(userId) {
+        const db = getDb();
+        await db
+            .update(schema.users)
+            .set({ pendingInstallationRequest: null, updatedAt: new Date() })
+            .where(eq(schema.users.id, userId));
+    },
+};
+export const githubInstallationQueries = {
+    async findById(id) {
+        const db = getDb();
+        const result = await db.select().from(schema.githubInstallations).where(eq(schema.githubInstallations.id, id));
+        return result[0] ?? null;
+    },
+    async findByInstallationId(installationId) {
+        const db = getDb();
+        const result = await db
+            .select()
+            .from(schema.githubInstallations)
+            .where(eq(schema.githubInstallations.installationId, installationId));
+        return result[0] ?? null;
+    },
+    async findByAccountLogin(accountLogin) {
+        const db = getDb();
+        const result = await db
+            .select()
+            .from(schema.githubInstallations)
+            .where(eq(schema.githubInstallations.accountLogin, accountLogin));
+        return result[0] ?? null;
+    },
+    async findByInstalledBy(userId) {
+        const db = getDb();
+        return db
+            .select()
+            .from(schema.githubInstallations)
+            .where(eq(schema.githubInstallations.installedById, userId));
+    },
+    async findAll() {
+        const db = getDb();
+        return db.select().from(schema.githubInstallations).orderBy(schema.githubInstallations.accountLogin);
+    },
+    async upsert(data) {
+        const db = getDb();
+        const result = await db
+            .insert(schema.githubInstallations)
+            .values(data)
+            .onConflictDoUpdate({
+            target: schema.githubInstallations.installationId,
+            set: {
+                accountType: data.accountType,
+                accountLogin: data.accountLogin,
+                accountId: data.accountId,
+                permissions: data.permissions,
+                events: data.events,
+                installedById: data.installedById,
+                updatedAt: new Date(),
+            },
+        })
+            .returning();
+        return result[0];
+    },
+    async updatePermissions(installationId, permissions, events) {
+        const db = getDb();
+        await db
+            .update(schema.githubInstallations)
+            .set({ permissions, events, updatedAt: new Date() })
+            .where(eq(schema.githubInstallations.installationId, installationId));
+    },
+    async suspend(installationId, suspendedBy) {
+        const db = getDb();
+        await db
+            .update(schema.githubInstallations)
+            .set({ suspended: true, suspendedAt: new Date(), suspendedBy, updatedAt: new Date() })
+            .where(eq(schema.githubInstallations.installationId, installationId));
+    },
+    async unsuspend(installationId) {
+        const db = getDb();
+        await db
+            .update(schema.githubInstallations)
+            .set({ suspended: false, suspendedAt: null, suspendedBy: null, updatedAt: new Date() })
+            .where(eq(schema.githubInstallations.installationId, installationId));
+    },
+    async delete(installationId) {
+        const db = getDb();
+        await db.delete(schema.githubInstallations).where(eq(schema.githubInstallations.installationId, installationId));
+    },
+};
+export const credentialQueries = {
+    async findByUserId(userId) {
+        const db = getDb();
+        return db.select().from(schema.credentials).where(eq(schema.credentials.userId, userId));
+    },
+    async findByUserAndWorkspace(userId, workspaceId) {
+        const db = getDb();
+        // Return credentials for this workspace OR legacy credentials (NULL workspace_id)
+        // This ensures backward compatibility with existing credentials
+        return db
+            .select()
+            .from(schema.credentials)
+            .where(and(eq(schema.credentials.userId, userId), or(eq(schema.credentials.workspaceId, workspaceId), isNull(schema.credentials.workspaceId))));
+    },
+    async findByUserWorkspaceAndProvider(userId, workspaceId, provider) {
+        const db = getDb();
+        const result = await db
+            .select()
+            .from(schema.credentials)
+            .where(and(eq(schema.credentials.userId, userId), eq(schema.credentials.workspaceId, workspaceId), eq(schema.credentials.provider, provider)));
+        return result[0] ?? null;
+    },
+    async findByUserAndProvider(userId, provider) {
+        // Legacy: returns first match (any workspace) - use findByUserWorkspaceAndProvider instead
+        const db = getDb();
+        const result = await db
+            .select()
+            .from(schema.credentials)
+            .where(and(eq(schema.credentials.userId, userId), eq(schema.credentials.provider, provider)));
+        return result[0] ?? null;
+    },
+    async upsert(data) {
+        const db = getDb();
+        const result = await db
+            .insert(schema.credentials)
+            .values(data)
+            .onConflictDoUpdate({
+            target: [schema.credentials.userId, schema.credentials.provider, schema.credentials.workspaceId],
+            set: {
+                scopes: data.scopes,
+                providerAccountId: data.providerAccountId,
+                providerAccountEmail: data.providerAccountEmail,
+                updatedAt: new Date(),
+            },
+        })
+            .returning();
+        return result[0];
+    },
+    async deleteForWorkspace(userId, workspaceId, provider) {
+        const db = getDb();
+        await db
+            .delete(schema.credentials)
+            .where(and(eq(schema.credentials.userId, userId), eq(schema.credentials.workspaceId, workspaceId), eq(schema.credentials.provider, provider)));
+    },
+    async delete(userId, provider) {
+        // Legacy: deletes all workspace credentials for this provider
+        const db = getDb();
+        await db
+            .delete(schema.credentials)
+            .where(and(eq(schema.credentials.userId, userId), eq(schema.credentials.provider, provider)));
+    },
+};
+export const workspaceQueries = {
+    async findById(id) {
+        const db = getDb();
+        const result = await db.select().from(schema.workspaces).where(eq(schema.workspaces.id, id));
+        return result[0] ?? null;
+    },
+    async findByUserId(userId) {
+        const db = getDb();
+        return db
+            .select()
+            .from(schema.workspaces)
+            .where(eq(schema.workspaces.userId, userId))
+            .orderBy(desc(schema.workspaces.createdAt));
+    },
+    async findByCustomDomain(domain) {
+        const db = getDb();
+        const result = await db
+            .select()
+            .from(schema.workspaces)
+            .where(eq(schema.workspaces.customDomain, domain));
+        return result[0] ?? null;
+    },
+    async findByRepoFullName(repoFullName) {
+        const db = getDb();
+        // Find repository by full name (case-insensitive), then get its workspace
+        const result = await db
+            .select({ workspace: schema.workspaces })
+            .from(schema.repositories)
+            .innerJoin(schema.workspaces, eq(schema.repositories.workspaceId, schema.workspaces.id))
+            .where(sql `LOWER(${schema.repositories.githubFullName}) = LOWER(${repoFullName})`)
+            .limit(1);
+        return result[0]?.workspace ?? null;
+    },
+    async findAll() {
+        const db = getDb();
+        return db
+            .select()
+            .from(schema.workspaces)
+            .orderBy(desc(schema.workspaces.createdAt));
+    },
+    async create(data) {
+        const db = getDb();
+        const result = await db.insert(schema.workspaces).values(data).returning();
+        return result[0];
+    },
+    async update(id, data) {
+        const db = getDb();
+        await db
+            .update(schema.workspaces)
+            .set({ ...data, updatedAt: new Date() })
+            .where(eq(schema.workspaces.id, id));
+    },
+    async updateStatus(id, status, options) {
+        const db = getDb();
+        await db
+            .update(schema.workspaces)
+            .set({
+            status,
+            computeId: options?.computeId,
+            publicUrl: options?.publicUrl,
+            errorMessage: options?.errorMessage,
+            updatedAt: new Date(),
+        })
+            .where(eq(schema.workspaces.id, id));
+    },
+    async updateConfig(id, config) {
+        const db = getDb();
+        await db
+            .update(schema.workspaces)
+            .set({
+            config,
+            updatedAt: new Date(),
+        })
+            .where(eq(schema.workspaces.id, id));
+    },
+    async setCustomDomain(id, customDomain, status = 'pending') {
+        const db = getDb();
+        await db
+            .update(schema.workspaces)
+            .set({ customDomain, customDomainStatus: status, updatedAt: new Date() })
+            .where(eq(schema.workspaces.id, id));
+    },
+    async updateCustomDomainStatus(id, status) {
+        const db = getDb();
+        await db
+            .update(schema.workspaces)
+            .set({ customDomainStatus: status, updatedAt: new Date() })
+            .where(eq(schema.workspaces.id, id));
+    },
+    async removeCustomDomain(id) {
+        const db = getDb();
+        await db
+            .update(schema.workspaces)
+            .set({ customDomain: null, customDomainStatus: null, updatedAt: new Date() })
+            .where(eq(schema.workspaces.id, id));
+    },
+    async delete(id) {
+        const db = getDb();
+        await db.delete(schema.workspaces).where(eq(schema.workspaces.id, id));
+    },
+};
+export const workspaceMemberQueries = {
+    async findByWorkspaceId(workspaceId) {
+        const db = getDb();
+        return db
+            .select()
+            .from(schema.workspaceMembers)
+            .where(eq(schema.workspaceMembers.workspaceId, workspaceId));
+    },
+    async findByUserId(userId) {
+        const db = getDb();
+        return db
+            .select()
+            .from(schema.workspaceMembers)
+            .where(and(eq(schema.workspaceMembers.userId, userId), isNotNull(schema.workspaceMembers.acceptedAt)));
+    },
+    async findMembership(workspaceId, userId) {
+        const db = getDb();
+        const result = await db
+            .select()
+            .from(schema.workspaceMembers)
+            .where(and(eq(schema.workspaceMembers.workspaceId, workspaceId), eq(schema.workspaceMembers.userId, userId)));
+        return result[0] ?? null;
+    },
+    async addMember(data) {
+        const db = getDb();
+        const result = await db
+            .insert(schema.workspaceMembers)
+            .values({
+            workspaceId: data.workspaceId,
+            userId: data.userId,
+            role: data.role,
+            invitedBy: data.invitedBy,
+        })
+            .returning();
+        return result[0];
+    },
+    async acceptInvite(workspaceId, userId) {
+        const db = getDb();
+        await db
+            .update(schema.workspaceMembers)
+            .set({ acceptedAt: new Date() })
+            .where(and(eq(schema.workspaceMembers.workspaceId, workspaceId), eq(schema.workspaceMembers.userId, userId)));
+    },
+    async updateRole(workspaceId, userId, role) {
+        const db = getDb();
+        await db
+            .update(schema.workspaceMembers)
+            .set({ role })
+            .where(and(eq(schema.workspaceMembers.workspaceId, workspaceId), eq(schema.workspaceMembers.userId, userId)));
+    },
+    async removeMember(workspaceId, userId) {
+        const db = getDb();
+        await db
+            .delete(schema.workspaceMembers)
+            .where(and(eq(schema.workspaceMembers.workspaceId, workspaceId), eq(schema.workspaceMembers.userId, userId)));
+    },
+    async getPendingInvites(userId) {
+        const db = getDb();
+        return db
+            .select()
+            .from(schema.workspaceMembers)
+            .where(and(eq(schema.workspaceMembers.userId, userId), isNull(schema.workspaceMembers.acceptedAt)));
+    },
+    async isOwner(workspaceId, userId) {
+        const db = getDb();
+        const result = await db
+            .select()
+            .from(schema.workspaceMembers)
+            .where(and(eq(schema.workspaceMembers.workspaceId, workspaceId), eq(schema.workspaceMembers.userId, userId), eq(schema.workspaceMembers.role, 'owner')));
+        return result.length > 0;
+    },
+    async canEdit(workspaceId, userId) {
+        const db = getDb();
+        const result = await db
+            .select()
+            .from(schema.workspaceMembers)
+            .where(and(eq(schema.workspaceMembers.workspaceId, workspaceId), eq(schema.workspaceMembers.userId, userId), isNotNull(schema.workspaceMembers.acceptedAt)));
+        const member = result[0];
+        return !!member && ['owner', 'admin', 'member'].includes(member.role);
+    },
+    async canView(workspaceId, userId) {
+        const db = getDb();
+        const result = await db
+            .select()
+            .from(schema.workspaceMembers)
+            .where(and(eq(schema.workspaceMembers.workspaceId, workspaceId), eq(schema.workspaceMembers.userId, userId), isNotNull(schema.workspaceMembers.acceptedAt)));
+        return result.length > 0;
+    },
+};
+export const linkedDaemonQueries = {
+    async findById(id) {
+        const db = getDb();
+        const result = await db.select().from(schema.linkedDaemons).where(eq(schema.linkedDaemons.id, id));
+        return result[0] ?? null;
+    },
+    async findByUserId(userId) {
+        const db = getDb();
+        return db
+            .select()
+            .from(schema.linkedDaemons)
+            .where(eq(schema.linkedDaemons.userId, userId))
+            .orderBy(desc(schema.linkedDaemons.lastSeenAt));
+    },
+    async findByWorkspaceId(workspaceId) {
+        const db = getDb();
+        return db
+            .select()
+            .from(schema.linkedDaemons)
+            .where(eq(schema.linkedDaemons.workspaceId, workspaceId))
+            .orderBy(desc(schema.linkedDaemons.lastSeenAt));
+    },
+    async findByMachineId(userId, machineId) {
+        const db = getDb();
+        const result = await db
+            .select()
+            .from(schema.linkedDaemons)
+            .where(and(eq(schema.linkedDaemons.userId, userId), eq(schema.linkedDaemons.machineId, machineId)));
+        return result[0] ?? null;
+    },
+    async findByApiKeyHash(apiKeyHash) {
+        const db = getDb();
+        const result = await db
+            .select()
+            .from(schema.linkedDaemons)
+            .where(eq(schema.linkedDaemons.apiKeyHash, apiKeyHash));
+        return result[0] ?? null;
+    },
+    async create(data) {
+        const db = getDb();
+        const result = await db
+            .insert(schema.linkedDaemons)
+            .values({ ...data, lastSeenAt: new Date() })
+            .returning();
+        return result[0];
+    },
+    async update(id, data) {
+        const db = getDb();
+        await db
+            .update(schema.linkedDaemons)
+            .set({ ...data, updatedAt: new Date() })
+            .where(eq(schema.linkedDaemons.id, id));
+    },
+    async updateLastSeen(id) {
+        const db = getDb();
+        await db
+            .update(schema.linkedDaemons)
+            .set({ lastSeenAt: new Date(), status: 'online', updatedAt: new Date() })
+            .where(eq(schema.linkedDaemons.id, id));
+    },
+    async delete(id) {
+        const db = getDb();
+        await db.delete(schema.linkedDaemons).where(eq(schema.linkedDaemons.id, id));
+    },
+    async markStale() {
+        const db = getDb();
+        const twoMinutesAgo = new Date(Date.now() - 2 * 60 * 1000);
+        const result = await db
+            .update(schema.linkedDaemons)
+            .set({ status: 'offline' })
+            .where(and(eq(schema.linkedDaemons.status, 'online'), lt(schema.linkedDaemons.lastSeenAt, twoMinutesAgo)));
+        return result.rowCount ?? 0;
+    },
+    async getAllAgentsForUser(userId) {
+        const db = getDb();
+        const daemons = await db
+            .select()
+            .from(schema.linkedDaemons)
+            .where(eq(schema.linkedDaemons.userId, userId));
+        return daemons.map((d) => ({
+            daemonId: d.id,
+            daemonName: d.name,
+            machineId: d.machineId,
+            agents: d.metadata?.agents || [],
+        }));
+    },
+    async getPendingUpdates(id) {
+        const db = getDb();
+        const result = await db.select().from(schema.linkedDaemons).where(eq(schema.linkedDaemons.id, id));
+        const daemon = result[0];
+        if (!daemon)
+            return [];
+        const updates = daemon.pendingUpdates || [];
+        // Clear after reading
+        if (updates.length > 0) {
+            await db
+                .update(schema.linkedDaemons)
+                .set({ pendingUpdates: [] })
+                .where(eq(schema.linkedDaemons.id, id));
+        }
+        return updates;
+    },
+    async queueUpdate(id, update) {
+        const db = getDb();
+        const result = await db.select().from(schema.linkedDaemons).where(eq(schema.linkedDaemons.id, id));
+        const daemon = result[0];
+        if (!daemon)
+            return;
+        const existing = daemon.pendingUpdates || [];
+        await db
+            .update(schema.linkedDaemons)
+            .set({ pendingUpdates: [...existing, update], updatedAt: new Date() })
+            .where(eq(schema.linkedDaemons.id, id));
+    },
+    async queueMessage(id, message) {
+        const db = getDb();
+        const result = await db.select().from(schema.linkedDaemons).where(eq(schema.linkedDaemons.id, id));
+        const daemon = result[0];
+        if (!daemon)
+            return;
+        const existing = daemon.messageQueue || [];
+        await db
+            .update(schema.linkedDaemons)
+            .set({ messageQueue: [...existing, message], updatedAt: new Date() })
+            .where(eq(schema.linkedDaemons.id, id));
+    },
+    async getQueuedMessages(id) {
+        const db = getDb();
+        const result = await db.select().from(schema.linkedDaemons).where(eq(schema.linkedDaemons.id, id));
+        const daemon = result[0];
+        return daemon?.messageQueue || [];
+    },
+    async clearMessageQueue(id) {
+        const db = getDb();
+        await db
+            .update(schema.linkedDaemons)
+            .set({ messageQueue: [] })
+            .where(eq(schema.linkedDaemons.id, id));
+    },
+};
+export const projectGroupQueries = {
+    async findById(id) {
+        const db = getDb();
+        const result = await db.select().from(schema.projectGroups).where(eq(schema.projectGroups.id, id));
+        return result[0] ?? null;
+    },
+    async findByUserId(userId) {
+        const db = getDb();
+        return db
+            .select()
+            .from(schema.projectGroups)
+            .where(eq(schema.projectGroups.userId, userId))
+            .orderBy(schema.projectGroups.sortOrder, schema.projectGroups.name);
+    },
+    async findByName(userId, name) {
+        const db = getDb();
+        const result = await db
+            .select()
+            .from(schema.projectGroups)
+            .where(and(eq(schema.projectGroups.userId, userId), eq(schema.projectGroups.name, name)));
+        return result[0] ?? null;
+    },
+    async create(data) {
+        const db = getDb();
+        const result = await db.insert(schema.projectGroups).values(data).returning();
+        return result[0];
+    },
+    async update(id, data) {
+        const db = getDb();
+        await db
+            .update(schema.projectGroups)
+            .set({ ...data, updatedAt: new Date() })
+            .where(eq(schema.projectGroups.id, id));
+    },
+    async delete(id) {
+        const db = getDb();
+        // Repositories in this group will have projectGroupId set to null (ON DELETE SET NULL)
+        await db.delete(schema.projectGroups).where(eq(schema.projectGroups.id, id));
+    },
+    async findWithRepositories(id) {
+        const db = getDb();
+        const group = await db.select().from(schema.projectGroups).where(eq(schema.projectGroups.id, id));
+        if (!group[0])
+            return null;
+        const repos = await db
+            .select()
+            .from(schema.repositories)
+            .where(eq(schema.repositories.projectGroupId, id))
+            .orderBy(schema.repositories.githubFullName);
+        return { ...group[0], repositories: repos };
+    },
+    async findAllWithRepositories(userId) {
+        const db = getDb();
+        const groups = await db
+            .select()
+            .from(schema.projectGroups)
+            .where(eq(schema.projectGroups.userId, userId))
+            .orderBy(schema.projectGroups.sortOrder, schema.projectGroups.name);
+        // Get repositories for each group
+        const result = await Promise.all(groups.map(async (group) => {
+            const repos = await db
+                .select()
+                .from(schema.repositories)
+                .where(eq(schema.repositories.projectGroupId, group.id))
+                .orderBy(schema.repositories.githubFullName);
+            return { ...group, repositories: repos };
+        }));
+        // Also get ungrouped repositories
+        const ungroupedRepos = await db
+            .select()
+            .from(schema.repositories)
+            .where(and(eq(schema.repositories.userId, userId), isNull(schema.repositories.projectGroupId)))
+            .orderBy(schema.repositories.githubFullName);
+        return { groups: result, ungroupedRepositories: ungroupedRepos };
+    },
+    async updateCoordinatorAgent(id, config) {
+        const db = getDb();
+        await db
+            .update(schema.projectGroups)
+            .set({ coordinatorAgent: config, updatedAt: new Date() })
+            .where(eq(schema.projectGroups.id, id));
+    },
+    async reorder(userId, orderedIds) {
+        const db = getDb();
+        // Update sort_order for each group
+        await Promise.all(orderedIds.map((id, index) => db
+            .update(schema.projectGroups)
+            .set({ sortOrder: index, updatedAt: new Date() })
+            .where(and(eq(schema.projectGroups.id, id), eq(schema.projectGroups.userId, userId)))));
+    },
+};
+export const repositoryQueries = {
+    async findById(id) {
+        const db = getDb();
+        const result = await db.select().from(schema.repositories).where(eq(schema.repositories.id, id));
+        return result[0] ?? null;
+    },
+    async findByFullName(fullName) {
+        const db = getDb();
+        const result = await db
+            .select()
+            .from(schema.repositories)
+            .where(eq(schema.repositories.githubFullName, fullName));
+        return result[0] ?? null;
+    },
+    async findByGithubFullName(fullName) {
+        const db = getDb();
+        // Use case-insensitive match since GitHub repo names are case-insensitive
+        return db
+            .select()
+            .from(schema.repositories)
+            .where(sql `LOWER(${schema.repositories.githubFullName}) = LOWER(${fullName})`);
+    },
+    async findByUserId(userId) {
+        const db = getDb();
+        return db
+            .select()
+            .from(schema.repositories)
+            .where(eq(schema.repositories.userId, userId))
+            .orderBy(schema.repositories.githubFullName);
+    },
+    async findByWorkspaceId(workspaceId) {
+        const db = getDb();
+        return db
+            .select()
+            .from(schema.repositories)
+            .where(eq(schema.repositories.workspaceId, workspaceId));
+    },
+    async findByProjectGroupId(projectGroupId) {
+        const db = getDb();
+        return db
+            .select()
+            .from(schema.repositories)
+            .where(eq(schema.repositories.projectGroupId, projectGroupId))
+            .orderBy(schema.repositories.githubFullName);
+    },
+    async upsert(data) {
+        const db = getDb();
+        const result = await db
+            .insert(schema.repositories)
+            .values(data)
+            .onConflictDoUpdate({
+            target: [schema.repositories.userId, schema.repositories.githubFullName],
+            set: {
+                githubId: data.githubId,
+                defaultBranch: data.defaultBranch,
+                isPrivate: data.isPrivate,
+                syncStatus: data.syncStatus,
+                nangoConnectionId: data.nangoConnectionId,
+                installationId: data.installationId,
+                lastSyncedAt: data.lastSyncedAt,
+                updatedAt: new Date(),
+            },
+        })
+            .returning();
+        return result[0];
+    },
+    async assignToWorkspace(repoId, workspaceId) {
+        const db = getDb();
+        await db
+            .update(schema.repositories)
+            .set({ workspaceId, updatedAt: new Date() })
+            .where(eq(schema.repositories.id, repoId));
+    },
+    async assignToGroup(repoId, projectGroupId) {
+        const db = getDb();
+        await db
+            .update(schema.repositories)
+            .set({ projectGroupId, updatedAt: new Date() })
+            .where(eq(schema.repositories.id, repoId));
+    },
+    async updateProjectAgent(id, config) {
+        const db = getDb();
+        await db
+            .update(schema.repositories)
+            .set({ projectAgent: config, updatedAt: new Date() })
+            .where(eq(schema.repositories.id, id));
+    },
+    async updateSyncStatus(id, status, lastSyncedAt) {
+        const db = getDb();
+        const updates = { syncStatus: status, updatedAt: new Date() };
+        if (lastSyncedAt) {
+            updates.lastSyncedAt = lastSyncedAt;
+        }
+        await db
+            .update(schema.repositories)
+            .set(updates)
+            .where(eq(schema.repositories.id, id));
+    },
+    async delete(id) {
+        const db = getDb();
+        await db.delete(schema.repositories).where(eq(schema.repositories.id, id));
+    },
+};
+export const agentSessionQueries = {
+    async findById(id) {
+        const db = getDb();
+        const result = await db.select().from(schema.agentSessions).where(eq(schema.agentSessions.id, id));
+        return result[0] ?? null;
+    },
+    async findByWorkspaceId(workspaceId) {
+        const db = getDb();
+        return db
+            .select()
+            .from(schema.agentSessions)
+            .where(eq(schema.agentSessions.workspaceId, workspaceId))
+            .orderBy(desc(schema.agentSessions.startedAt));
+    },
+    async findActiveByWorkspace(workspaceId) {
+        const db = getDb();
+        return db
+            .select()
+            .from(schema.agentSessions)
+            .where(and(eq(schema.agentSessions.workspaceId, workspaceId), eq(schema.agentSessions.status, 'active')));
+    },
+    async create(data) {
+        const db = getDb();
+        const result = await db.insert(schema.agentSessions).values(data).returning();
+        return result[0];
+    },
+    async endSession(id, endMarker) {
+        const db = getDb();
+        await db
+            .update(schema.agentSessions)
+            .set({
+            status: 'ended',
+            endedAt: new Date(),
+            endMarker: endMarker ?? null,
+        })
+            .where(eq(schema.agentSessions.id, id));
+    },
+    async delete(id) {
+        const db = getDb();
+        await db.delete(schema.agentSessions).where(eq(schema.agentSessions.id, id));
+    },
+};
+export const agentSummaryQueries = {
+    async findBySessionId(sessionId) {
+        const db = getDb();
+        return db
+            .select()
+            .from(schema.agentSummaries)
+            .where(eq(schema.agentSummaries.sessionId, sessionId))
+            .orderBy(schema.agentSummaries.createdAt);
+    },
+    async findLatestByAgent(agentName) {
+        const db = getDb();
+        const result = await db
+            .select()
+            .from(schema.agentSummaries)
+            .where(eq(schema.agentSummaries.agentName, agentName))
+            .orderBy(desc(schema.agentSummaries.createdAt))
+            .limit(1);
+        return result[0] ?? null;
+    },
+    async create(data) {
+        const db = getDb();
+        const result = await db.insert(schema.agentSummaries).values(data).returning();
+        return result[0];
+    },
+    async deleteBySession(sessionId) {
+        const db = getDb();
+        await db.delete(schema.agentSummaries).where(eq(schema.agentSummaries.sessionId, sessionId));
+    },
+};
+export const ciFailureEventQueries = {
+    async findById(id) {
+        const db = getDb();
+        const result = await db.select().from(schema.ciFailureEvents).where(eq(schema.ciFailureEvents.id, id));
+        return result[0] ?? null;
+    },
+    async findByRepository(repository, limit = 50) {
+        const db = getDb();
+        return db
+            .select()
+            .from(schema.ciFailureEvents)
+            .where(eq(schema.ciFailureEvents.repository, repository))
+            .orderBy(desc(schema.ciFailureEvents.createdAt))
+            .limit(limit);
+    },
+    async findByPR(repository, prNumber) {
+        const db = getDb();
+        return db
+            .select()
+            .from(schema.ciFailureEvents)
+            .where(and(eq(schema.ciFailureEvents.repository, repository), eq(schema.ciFailureEvents.prNumber, prNumber)))
+            .orderBy(desc(schema.ciFailureEvents.createdAt));
+    },
+    async findRecentUnprocessed(limit = 100) {
+        const db = getDb();
+        return db
+            .select()
+            .from(schema.ciFailureEvents)
+            .where(isNull(schema.ciFailureEvents.processedAt))
+            .orderBy(schema.ciFailureEvents.createdAt)
+            .limit(limit);
+    },
+    async create(data) {
+        const db = getDb();
+        const result = await db.insert(schema.ciFailureEvents).values(data).returning();
+        return result[0];
+    },
+    async markProcessed(id, agentSpawned) {
+        const db = getDb();
+        await db
+            .update(schema.ciFailureEvents)
+            .set({ processedAt: new Date(), agentSpawned })
+            .where(eq(schema.ciFailureEvents.id, id));
+    },
+    async delete(id) {
+        const db = getDb();
+        await db.delete(schema.ciFailureEvents).where(eq(schema.ciFailureEvents.id, id));
+    },
+};
+export const ciFixAttemptQueries = {
+    async findById(id) {
+        const db = getDb();
+        const result = await db.select().from(schema.ciFixAttempts).where(eq(schema.ciFixAttempts.id, id));
+        return result[0] ?? null;
+    },
+    async findByFailureEvent(failureEventId) {
+        const db = getDb();
+        return db
+            .select()
+            .from(schema.ciFixAttempts)
+            .where(eq(schema.ciFixAttempts.failureEventId, failureEventId))
+            .orderBy(desc(schema.ciFixAttempts.startedAt));
+    },
+    async findActiveByRepository(repository) {
+        const db = getDb();
+        // Find active fix attempts by joining with failure events
+        return db
+            .select({
+            id: schema.ciFixAttempts.id,
+            failureEventId: schema.ciFixAttempts.failureEventId,
+            agentId: schema.ciFixAttempts.agentId,
+            agentName: schema.ciFixAttempts.agentName,
+            status: schema.ciFixAttempts.status,
+            commitSha: schema.ciFixAttempts.commitSha,
+            errorMessage: schema.ciFixAttempts.errorMessage,
+            startedAt: schema.ciFixAttempts.startedAt,
+            completedAt: schema.ciFixAttempts.completedAt,
+        })
+            .from(schema.ciFixAttempts)
+            .innerJoin(schema.ciFailureEvents, eq(schema.ciFixAttempts.failureEventId, schema.ciFailureEvents.id))
+            .where(and(eq(schema.ciFailureEvents.repository, repository), sql `${schema.ciFixAttempts.status} IN ('pending', 'in_progress')`));
+    },
+    async create(data) {
+        const db = getDb();
+        const result = await db.insert(schema.ciFixAttempts).values(data).returning();
+        return result[0];
+    },
+    async updateStatus(id, status, errorMessage) {
+        const db = getDb();
+        const updates = { status };
+        if (errorMessage) {
+            updates.errorMessage = errorMessage;
+        }
+        await db
+            .update(schema.ciFixAttempts)
+            .set(updates)
+            .where(eq(schema.ciFixAttempts.id, id));
+    },
+    async complete(id, status, commitSha, errorMessage) {
+        const db = getDb();
+        await db
+            .update(schema.ciFixAttempts)
+            .set({
+            status,
+            completedAt: new Date(),
+            commitSha: commitSha ?? null,
+            errorMessage: errorMessage ?? null,
+        })
+            .where(eq(schema.ciFixAttempts.id, id));
+    },
+};
+export const issueAssignmentQueries = {
+    async findById(id) {
+        const db = getDb();
+        const result = await db.select().from(schema.issueAssignments).where(eq(schema.issueAssignments.id, id));
+        return result[0] ?? null;
+    },
+    async findByRepository(repository, limit = 50) {
+        const db = getDb();
+        return db
+            .select()
+            .from(schema.issueAssignments)
+            .where(eq(schema.issueAssignments.repository, repository))
+            .orderBy(desc(schema.issueAssignments.createdAt))
+            .limit(limit);
+    },
+    async findByIssue(repository, issueNumber) {
+        const db = getDb();
+        const result = await db
+            .select()
+            .from(schema.issueAssignments)
+            .where(and(eq(schema.issueAssignments.repository, repository), eq(schema.issueAssignments.issueNumber, issueNumber)));
+        return result[0] ?? null;
+    },
+    async findByAgent(agentId) {
+        const db = getDb();
+        return db
+            .select()
+            .from(schema.issueAssignments)
+            .where(eq(schema.issueAssignments.agentId, agentId))
+            .orderBy(desc(schema.issueAssignments.createdAt));
+    },
+    async findPending(limit = 100) {
+        const db = getDb();
+        return db
+            .select()
+            .from(schema.issueAssignments)
+            .where(eq(schema.issueAssignments.status, 'pending'))
+            .orderBy(schema.issueAssignments.createdAt)
+            .limit(limit);
+    },
+    async create(data) {
+        const db = getDb();
+        const result = await db.insert(schema.issueAssignments).values(data).returning();
+        return result[0];
+    },
+    async assignAgent(id, agentId, agentName) {
+        const db = getDb();
+        await db
+            .update(schema.issueAssignments)
+            .set({
+            agentId,
+            agentName,
+            assignedAt: new Date(),
+            status: 'assigned',
+            updatedAt: new Date(),
+        })
+            .where(eq(schema.issueAssignments.id, id));
+    },
+    async updateStatus(id, status, resolution) {
+        const db = getDb();
+        const updates = { status, updatedAt: new Date() };
+        if (resolution) {
+            updates.resolution = resolution;
+        }
+        await db
+            .update(schema.issueAssignments)
+            .set(updates)
+            .where(eq(schema.issueAssignments.id, id));
+    },
+    async linkPR(id, prNumber) {
+        const db = getDb();
+        await db
+            .update(schema.issueAssignments)
+            .set({ linkedPrNumber: prNumber, updatedAt: new Date() })
+            .where(eq(schema.issueAssignments.id, id));
+    },
+};
+export const commentMentionQueries = {
+    async findById(id) {
+        const db = getDb();
+        const result = await db.select().from(schema.commentMentions).where(eq(schema.commentMentions.id, id));
+        return result[0] ?? null;
+    },
+    async findByRepository(repository, limit = 50) {
+        const db = getDb();
+        return db
+            .select()
+            .from(schema.commentMentions)
+            .where(eq(schema.commentMentions.repository, repository))
+            .orderBy(desc(schema.commentMentions.createdAt))
+            .limit(limit);
+    },
+    async findBySource(sourceType, sourceId) {
+        const db = getDb();
+        const result = await db
+            .select()
+            .from(schema.commentMentions)
+            .where(and(eq(schema.commentMentions.sourceType, sourceType), eq(schema.commentMentions.sourceId, sourceId)));
+        return result[0] ?? null;
+    },
+    async findPending(limit = 100) {
+        const db = getDb();
+        return db
+            .select()
+            .from(schema.commentMentions)
+            .where(eq(schema.commentMentions.status, 'pending'))
+            .orderBy(schema.commentMentions.createdAt)
+            .limit(limit);
+    },
+    async findByMentionedAgent(mentionedAgent, limit = 50) {
+        const db = getDb();
+        return db
+            .select()
+            .from(schema.commentMentions)
+            .where(eq(schema.commentMentions.mentionedAgent, mentionedAgent))
+            .orderBy(desc(schema.commentMentions.createdAt))
+            .limit(limit);
+    },
+    async create(data) {
+        const db = getDb();
+        const result = await db.insert(schema.commentMentions).values(data).returning();
+        return result[0];
+    },
+    async markProcessing(id, agentId, agentName) {
+        const db = getDb();
+        await db
+            .update(schema.commentMentions)
+            .set({ status: 'processing', agentId, agentName })
+            .where(eq(schema.commentMentions.id, id));
+    },
+    async markResponded(id, responseCommentId, responseBody) {
+        const db = getDb();
+        await db
+            .update(schema.commentMentions)
+            .set({
+            status: 'responded',
+            responseCommentId,
+            responseBody,
+            respondedAt: new Date(),
+        })
+            .where(eq(schema.commentMentions.id, id));
+    },
+    async markIgnored(id) {
+        const db = getDb();
+        await db
+            .update(schema.commentMentions)
+            .set({ status: 'ignored' })
+            .where(eq(schema.commentMentions.id, id));
+    },
+};
+export const channelQueries = {
+    async findById(id) {
+        const db = getDb();
+        const result = await db.select().from(schema.channels).where(eq(schema.channels.id, id));
+        return result[0] ?? null;
+    },
+    async findByWorkspaceId(workspaceId) {
+        const db = getDb();
+        return db
+            .select()
+            .from(schema.channels)
+            .where(eq(schema.channels.workspaceId, workspaceId))
+            .orderBy(desc(schema.channels.lastActivityAt));
+    },
+    async findByWorkspaceAndChannelId(workspaceId, channelId) {
+        const db = getDb();
+        const result = await db
+            .select()
+            .from(schema.channels)
+            .where(and(eq(schema.channels.workspaceId, workspaceId), eq(schema.channels.channelId, channelId)));
+        return result[0] ?? null;
+    },
+    async create(channel) {
+        const db = getDb();
+        const result = await db.insert(schema.channels).values(channel).returning();
+        return result[0];
+    },
+    async update(id, updates) {
+        const db = getDb();
+        await db
+            .update(schema.channels)
+            .set({ ...updates, updatedAt: new Date() })
+            .where(eq(schema.channels.id, id));
+    },
+    async archive(id) {
+        const db = getDb();
+        await db
+            .update(schema.channels)
+            .set({ status: 'archived', updatedAt: new Date() })
+            .where(eq(schema.channels.id, id));
+    },
+    async unarchive(id) {
+        const db = getDb();
+        await db
+            .update(schema.channels)
+            .set({ status: 'active', updatedAt: new Date() })
+            .where(eq(schema.channels.id, id));
+    },
+    async delete(id) {
+        const db = getDb();
+        await db.delete(schema.channels).where(eq(schema.channels.id, id));
+    },
+};
+export const channelMemberQueries = {
+    async findByChannelId(channelId) {
+        const db = getDb();
+        return db
+            .select()
+            .from(schema.channelMembers)
+            .where(eq(schema.channelMembers.channelId, channelId));
+    },
+    async findByMemberId(memberId) {
+        const db = getDb();
+        return db
+            .select()
+            .from(schema.channelMembers)
+            .where(eq(schema.channelMembers.memberId, memberId));
+    },
+    async findMembership(channelId, memberId) {
+        const db = getDb();
+        const result = await db
+            .select()
+            .from(schema.channelMembers)
+            .where(and(eq(schema.channelMembers.channelId, channelId), eq(schema.channelMembers.memberId, memberId)));
+        return result[0] ?? null;
+    },
+    async addMember(member) {
+        const db = getDb();
+        const result = await db.insert(schema.channelMembers).values(member).returning();
+        return result[0];
+    },
+    async removeMember(channelId, memberId) {
+        const db = getDb();
+        await db
+            .delete(schema.channelMembers)
+            .where(and(eq(schema.channelMembers.channelId, channelId), eq(schema.channelMembers.memberId, memberId)));
+    },
+    async updateRole(channelId, memberId, role) {
+        const db = getDb();
+        await db
+            .update(schema.channelMembers)
+            .set({ role })
+            .where(and(eq(schema.channelMembers.channelId, channelId), eq(schema.channelMembers.memberId, memberId)));
+    },
+    async countByChannelIds(channelIds) {
+        if (channelIds.length === 0) {
+            return new Map();
+        }
+        const db = getDb();
+        const results = await db
+            .select({
+            channelId: schema.channelMembers.channelId,
+            count: sql `count(*)::int`,
+        })
+            .from(schema.channelMembers)
+            .where(inArray(schema.channelMembers.channelId, channelIds))
+            .groupBy(schema.channelMembers.channelId);
+        const countMap = new Map();
+        for (const row of results) {
+            countMap.set(row.channelId, row.count);
+        }
+        return countMap;
+    },
+};
+// ============================================================================
+// Migration helper
+// ============================================================================
+export async function runMigrations() {
+    const { migrate } = await import('drizzle-orm/node-postgres/migrator');
+    const { fileURLToPath } = await import('node:url');
+    const { dirname, join } = await import('node:path');
+    // Get migrations folder relative to this file (works in both dev and Docker)
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = dirname(__filename);
+    // In dist: packages/cloud/dist/db/drizzle.js -> need to go to packages/cloud/src/db/migrations
+    // The migrations are in src/db/migrations, not dist/db/migrations
+    const migrationsFolder = join(__dirname, '..', '..', 'src', 'db', 'migrations');
+    const db = getDb();
+    await migrate(db, { migrationsFolder });
+    console.log('Migrations complete');
+}
+// ============================================================================
+// Close connections
+// ============================================================================
+export async function closeDb() {
+    if (pool) {
+        await pool.end();
+        pool = null;
+        drizzleDb = null;
+    }
+}
+//# sourceMappingURL=drizzle.js.map