agent-relay 2.0.23 → 2.0.24

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

@@ -1,1422 +0,0 @@
-/**
- * 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));
-    },
-    async createEmailUser(data) {
-        const db = getDb();
-        const result = await db
-            .insert(schema.users)
-            .values({
-            email: data.email,
-            passwordHash: data.passwordHash,
-            displayName: data.displayName || null,
-            emailVerified: false,
-        })
-            .returning();
-        return result[0];
-    },
-    async verifyEmail(userId) {
-        const db = getDb();
-        await db
-            .update(schema.users)
-            .set({
-            emailVerified: true,
-            emailVerificationToken: null,
-            emailVerificationExpires: null,
-            updatedAt: new Date(),
-        })
-            .where(eq(schema.users.id, userId));
-    },
-    async setEmailVerificationToken(userId, token, expires) {
-        const db = getDb();
-        await db
-            .update(schema.users)
-            .set({
-            emailVerificationToken: token,
-            emailVerificationExpires: expires,
-            updatedAt: new Date(),
-        })
-            .where(eq(schema.users.id, userId));
-    },
-    async findByEmailVerificationToken(token) {
-        const db = getDb();
-        const result = await db
-            .select()
-            .from(schema.users)
-            .where(eq(schema.users.emailVerificationToken, token));
-        return result[0] ?? null;
-    },
-    async updatePassword(userId, passwordHash) {
-        const db = getDb();
-        await db
-            .update(schema.users)
-            .set({ passwordHash, updatedAt: new Date() })
-            .where(eq(schema.users.id, userId));
-    },
-};
-export const userEmailQueries = {
-    async findByUserId(userId) {
-        const db = getDb();
-        return db
-            .select()
-            .from(schema.userEmails)
-            .where(eq(schema.userEmails.userId, userId));
-    },
-    async findUserByEmail(email) {
-        const db = getDb();
-        // First check user_emails table for linked emails
-        const linkedEmail = await db
-            .select({ userId: schema.userEmails.userId })
-            .from(schema.userEmails)
-            .where(eq(schema.userEmails.email, email.toLowerCase()))
-            .limit(1);
-        if (linkedEmail[0]) {
-            const user = await db
-                .select()
-                .from(schema.users)
-                .where(eq(schema.users.id, linkedEmail[0].userId));
-            return user[0] ?? null;
-        }
-        // Fall back to checking users.email directly
-        const user = await db
-            .select()
-            .from(schema.users)
-            .where(eq(schema.users.email, email.toLowerCase()));
-        return user[0] ?? null;
-    },
-    async upsert(data) {
-        const db = getDb();
-        const result = await db
-            .insert(schema.userEmails)
-            .values({
-            userId: data.userId,
-            email: data.email.toLowerCase(),
-            verified: data.verified,
-            primary: data.primary,
-            source: data.source ?? 'github',
-        })
-            .onConflictDoUpdate({
-            target: [schema.userEmails.userId, schema.userEmails.email],
-            set: {
-                verified: data.verified,
-                primary: data.primary,
-                updatedAt: new Date(),
-            },
-        })
-            .returning();
-        return result[0];
-    },
-    async syncFromGitHub(userId, emails) {
-        const db = getDb();
-        // Delete existing GitHub-sourced emails for this user
-        await db
-            .delete(schema.userEmails)
-            .where(and(eq(schema.userEmails.userId, userId), eq(schema.userEmails.source, 'github')));
-        // Insert all new emails
-        if (emails.length > 0) {
-            await db.insert(schema.userEmails).values(emails.map(e => ({
-                userId,
-                email: e.email.toLowerCase(),
-                verified: e.verified,
-                primary: e.primary,
-                source: 'github',
-            })));
-        }
-    },
-    async delete(userId, email) {
-        const db = getDb();
-        await db
-            .delete(schema.userEmails)
-            .where(and(eq(schema.userEmails.userId, userId), eq(schema.userEmails.email, email.toLowerCase())));
-    },
-    async isEmailLinkedToOtherUser(email, excludeUserId) {
-        const db = getDb();
-        const result = await db
-            .select({ userId: schema.userEmails.userId })
-            .from(schema.userEmails)
-            .where(and(eq(schema.userEmails.email, email.toLowerCase()), sql `${schema.userEmails.userId} != ${excludeUserId}`))
-            .limit(1);
-        return result.length > 0;
-    },
-};
-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