agent-relay 1.0.22 → 1.2.0

package/dist/cloud/db/drizzle.js

@@ -0,0 +1,1083 @@
+/**
+ * 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, sql, desc, lt, isNull, isNotNull } from 'drizzle-orm';
+import * as schema from './schema.js';
+import { getConfig } from '../config.js';
+// Re-export schema for direct table access
+export * from './schema.js';
+// Initialize pool and drizzle lazily
+let pool = null;
+let drizzleDb = null;
+function getPool() {
+    if (!pool) {
+        const config = getConfig();
+        pool = new Pool({ connectionString: config.databaseUrl });
+    }
+    return pool;
+}
+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 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 findByUserAndProvider(userId, provider) {
+        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],
+            set: {
+                accessToken: data.accessToken,
+                refreshToken: data.refreshToken ?? sql `credentials.refresh_token`,
+                tokenExpiresAt: data.tokenExpiresAt,
+                scopes: data.scopes,
+                providerAccountId: data.providerAccountId,
+                providerAccountEmail: data.providerAccountEmail,
+                updatedAt: new Date(),
+            },
+        })
+            .returning();
+        return result[0];
+    },
+    async updateTokens(userId, provider, accessToken, refreshToken, expiresAt) {
+        const db = getDb();
+        const updates = {
+            accessToken,
+            updatedAt: new Date(),
+        };
+        if (refreshToken !== undefined) {
+            updates.refreshToken = refreshToken;
+        }
+        if (expiresAt !== undefined) {
+            updates.tokenExpiresAt = expiresAt;
+        }
+        await db
+            .update(schema.credentials)
+            .set(updates)
+            .where(and(eq(schema.credentials.userId, userId), eq(schema.credentials.provider, provider)));
+    },
+    async delete(userId, 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 create(data) {
+        const db = getDb();
+        const result = await db.insert(schema.workspaces).values(data).returning();
+        return result[0];
+    },
+    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 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 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,
+                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));
+    },
+};
+// ============================================================================
+// Migration helper
+// ============================================================================
+export async function runMigrations() {
+    const { migrate } = await import('drizzle-orm/node-postgres/migrator');
+    const db = getDb();
+    await migrate(db, { migrationsFolder: './src/cloud/db/migrations' });
+    console.log('Migrations complete');
+}
+// ============================================================================
+// Close connections
+// ============================================================================
+export async function closeDb() {
+    if (pool) {
+        await pool.end();
+        pool = null;
+        drizzleDb = null;
+    }
+}
+//# sourceMappingURL=drizzle.js.map