agent-relay 2.0.23 → 2.0.24

package/packages/cloud/dist/db/bulk-ingest.js

@@ -1,268 +0,0 @@
-/**
- * Bulk Ingest Utilities
- *
- * Optimized bulk insert operations for high-volume message sync.
- * Uses raw SQL for performance instead of ORM-generated queries.
- *
- * Key optimizations:
- * - Multi-row INSERT with VALUES for batches
- * - Streaming COPY for very large batches (>1000 rows)
- * - Proper JSONB serialization
- * - Connection reuse via pool
- * - Chunk processing for memory efficiency
- */
-export const DEFAULT_POOL_CONFIG = {
-    max: 20,
-    idleTimeoutMillis: 30000,
-    connectionTimeoutMillis: 10000,
-};
-/**
- * Bulk insert messages using optimized multi-row INSERT.
- *
- * Uses ON CONFLICT DO NOTHING for deduplication.
- * Much faster than individual inserts for batches.
- *
- * @param pool Database connection pool
- * @param messages Messages to insert
- * @param chunkSize Number of rows per INSERT statement (default: 100)
- */
-export async function bulkInsertMessages(pool, messages, chunkSize = 100) {
-    if (messages.length === 0) {
-        return { inserted: 0, duplicates: 0, errors: 0, durationMs: 0 };
-    }
-    const startTime = Date.now();
-    let totalInserted = 0;
-    let totalErrors = 0;
-    // Process in chunks to avoid query size limits
-    for (let i = 0; i < messages.length; i += chunkSize) {
-        const chunk = messages.slice(i, i + chunkSize);
-        const result = await insertMessageChunk(pool, chunk);
-        totalInserted += result.inserted;
-        totalErrors += result.errors;
-    }
-    return {
-        inserted: totalInserted,
-        duplicates: messages.length - totalInserted - totalErrors,
-        errors: totalErrors,
-        durationMs: Date.now() - startTime,
-    };
-}
-/**
- * Insert a chunk of messages with multi-row VALUES.
- */
-async function insertMessageChunk(pool, messages) {
-    if (messages.length === 0) {
-        return { inserted: 0, errors: 0 };
-    }
-    // Build parameterized multi-row INSERT
-    const columns = [
-        'workspace_id',
-        'daemon_id',
-        'original_id',
-        'from_agent',
-        'to_agent',
-        'body',
-        'kind',
-        'topic',
-        'thread',
-        'channel',
-        'is_broadcast',
-        'is_urgent',
-        'data',
-        'payload_meta',
-        'message_ts',
-        'expires_at',
-    ];
-    const values = [];
-    const placeholders = [];
-    for (let i = 0; i < messages.length; i++) {
-        const msg = messages[i];
-        const offset = i * columns.length;
-        const rowPlaceholders = columns.map((_, j) => `$${offset + j + 1}`);
-        placeholders.push(`(${rowPlaceholders.join(', ')})`);
-        values.push(msg.workspaceId, msg.daemonId ?? null, msg.originalId, msg.fromAgent, msg.toAgent, msg.body, msg.kind ?? 'message', msg.topic ?? null, msg.thread ?? null, msg.channel ?? null, msg.isBroadcast ?? false, msg.isUrgent ?? false, msg.data ? JSON.stringify(msg.data) : null, msg.payloadMeta ? JSON.stringify(msg.payloadMeta) : null, msg.messageTs, msg.expiresAt ?? null);
-    }
-    const query = `
-    INSERT INTO agent_messages (${columns.join(', ')})
-    VALUES ${placeholders.join(', ')}
-    ON CONFLICT (workspace_id, original_id) DO NOTHING
-  `;
-    try {
-        const result = await pool.query(query, values);
-        return { inserted: result.rowCount ?? 0, errors: 0 };
-    }
-    catch (err) {
-        console.error('[bulk-ingest] Chunk insert failed:', err);
-        return { inserted: 0, errors: messages.length };
-    }
-}
-/**
- * Streaming bulk insert using staging table for very large batches.
- *
- * Uses chunked multi-row INSERT into a temp staging table,
- * then a single INSERT SELECT for deduplication.
- * This avoids holding all data in memory and is efficient for large batches.
- *
- * @param pool Database connection pool
- * @param messages Messages to insert
- */
-export async function streamingBulkInsert(pool, messages) {
-    if (messages.length === 0) {
-        return { inserted: 0, duplicates: 0, errors: 0, durationMs: 0 };
-    }
-    const startTime = Date.now();
-    const client = await pool.connect();
-    try {
-        // Start transaction
-        await client.query('BEGIN');
-        // Create temp staging table
-        await client.query(`
-      CREATE TEMP TABLE _staging_messages (
-        workspace_id UUID NOT NULL,
-        daemon_id UUID,
-        original_id VARCHAR(255) NOT NULL,
-        from_agent VARCHAR(255) NOT NULL,
-        to_agent VARCHAR(255) NOT NULL,
-        body TEXT NOT NULL,
-        kind VARCHAR(50) DEFAULT 'message',
-        topic VARCHAR(255),
-        thread VARCHAR(255),
-        channel VARCHAR(255),
-        is_broadcast BOOLEAN DEFAULT false,
-        is_urgent BOOLEAN DEFAULT false,
-        data JSONB,
-        payload_meta JSONB,
-        message_ts TIMESTAMP NOT NULL,
-        expires_at TIMESTAMP
-      ) ON COMMIT DROP
-    `);
-        // Insert into staging table in chunks
-        const chunkSize = 200;
-        for (let i = 0; i < messages.length; i += chunkSize) {
-            const chunk = messages.slice(i, i + chunkSize);
-            await insertStagingChunk(client, chunk);
-        }
-        // Insert from staging to main table with dedup
-        const result = await client.query(`
-      INSERT INTO agent_messages (
-        workspace_id, daemon_id, original_id, from_agent, to_agent, body,
-        kind, topic, thread, channel, is_broadcast, is_urgent,
-        data, payload_meta, message_ts, expires_at
-      )
-      SELECT
-        workspace_id, daemon_id, original_id, from_agent, to_agent, body,
-        kind, topic, thread, channel, is_broadcast, is_urgent,
-        data, payload_meta, message_ts, expires_at
-      FROM _staging_messages
-      ON CONFLICT (workspace_id, original_id) DO NOTHING
-    `);
-        await client.query('COMMIT');
-        return {
-            inserted: result.rowCount ?? 0,
-            duplicates: messages.length - (result.rowCount ?? 0),
-            errors: 0,
-            durationMs: Date.now() - startTime,
-        };
-    }
-    catch (err) {
-        await client.query('ROLLBACK').catch(() => { });
-        console.error('[bulk-ingest] Streaming insert failed:', err);
-        return {
-            inserted: 0,
-            duplicates: 0,
-            errors: messages.length,
-            durationMs: Date.now() - startTime,
-        };
-    }
-    finally {
-        client.release();
-    }
-}
-/**
- * Insert a chunk of messages into the staging table.
- */
-async function insertStagingChunk(client, messages) {
-    if (messages.length === 0)
-        return;
-    const columns = [
-        'workspace_id',
-        'daemon_id',
-        'original_id',
-        'from_agent',
-        'to_agent',
-        'body',
-        'kind',
-        'topic',
-        'thread',
-        'channel',
-        'is_broadcast',
-        'is_urgent',
-        'data',
-        'payload_meta',
-        'message_ts',
-        'expires_at',
-    ];
-    const values = [];
-    const placeholders = [];
-    for (let i = 0; i < messages.length; i++) {
-        const msg = messages[i];
-        const offset = i * columns.length;
-        const rowPlaceholders = columns.map((_, j) => `$${offset + j + 1}`);
-        placeholders.push(`(${rowPlaceholders.join(', ')})`);
-        values.push(msg.workspaceId, msg.daemonId ?? null, msg.originalId, msg.fromAgent, msg.toAgent, msg.body, msg.kind ?? 'message', msg.topic ?? null, msg.thread ?? null, msg.channel ?? null, msg.isBroadcast ?? false, msg.isUrgent ?? false, msg.data ? JSON.stringify(msg.data) : null, msg.payloadMeta ? JSON.stringify(msg.payloadMeta) : null, msg.messageTs, msg.expiresAt ?? null);
-    }
-    await client.query(`INSERT INTO _staging_messages (${columns.join(', ')}) VALUES ${placeholders.join(', ')}`, values);
-}
-/**
- * Optimized bulk insert that chooses strategy based on batch size.
- *
- * - Small batches (<100): Use regular ORM insert
- * - Medium batches (100-1000): Use multi-row INSERT
- * - Large batches (>1000): Use streaming COPY
- *
- * @param pool Database connection pool
- * @param messages Messages to insert
- */
-export async function optimizedBulkInsert(pool, messages) {
-    const count = messages.length;
-    if (count === 0) {
-        return { inserted: 0, duplicates: 0, errors: 0, durationMs: 0 };
-    }
-    // For very large batches, use streaming COPY
-    if (count > 1000) {
-        return streamingBulkInsert(pool, messages);
-    }
-    // For medium batches, use multi-row INSERT
-    return bulkInsertMessages(pool, messages);
-}
-/**
- * Get pool statistics for monitoring.
- */
-export function getPoolStats(pool) {
-    return {
-        total: pool.totalCount,
-        idle: pool.idleCount,
-        waiting: pool.waitingCount,
-    };
-}
-/**
- * Health check for the connection pool.
- */
-export async function checkPoolHealth(pool) {
-    const start = Date.now();
-    try {
-        await pool.query('SELECT 1');
-        return {
-            healthy: true,
-            latencyMs: Date.now() - start,
-        };
-    }
-    catch (err) {
-        return {
-            healthy: false,
-            latencyMs: Date.now() - start,
-            error: String(err),
-        };
-    }
-}
-//# sourceMappingURL=bulk-ingest.js.map

package/packages/cloud/dist/db/drizzle.d.ts

@@ -1,290 +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 { Pool } from 'pg';
-import * as schema from './schema.js';
-export type { User, NewUser, UserEmail, NewUserEmail, GitHubInstallation, NewGitHubInstallation, Credential, NewCredential, Workspace, NewWorkspace, WorkspaceConfig, WorkspaceMember, NewWorkspaceMember, ProjectGroup, NewProjectGroup, CoordinatorAgentConfig, ProjectAgentConfig, Repository, NewRepository, LinkedDaemon, NewLinkedDaemon, Subscription, NewSubscription, UsageRecord, NewUsageRecord, AgentSession, NewAgentSession, AgentSummary, NewAgentSummary, } from './schema.js';
-export * from './schema.js';
-/**
- * Get the raw connection pool for bulk operations.
- * Use this for optimized bulk inserts that bypass the ORM.
- */
-export declare function getRawPool(): Pool;
-export declare function getDb(): import("drizzle-orm/node-postgres").NodePgDatabase<Record<string, unknown>> & {
-    $client: Pool;
-};
-export interface UserQueries {
-    findById(id: string): Promise<schema.User | null>;
-    findByGithubId(githubId: string): Promise<schema.User | null>;
-    findByGithubUsername(username: string): Promise<schema.User | null>;
-    findByEmail(email: string): Promise<schema.User | null>;
-    findByNangoConnectionId(connectionId: string): Promise<schema.User | null>;
-    findByIncomingConnectionId(connectionId: string): Promise<schema.User | null>;
-    findByPlan(plan: string): Promise<schema.User[]>;
-    upsert(data: schema.NewUser): Promise<schema.User>;
-    update(id: string, data: Partial<Omit<schema.User, 'id' | 'createdAt'>>): Promise<void>;
-    completeOnboarding(userId: string): Promise<void>;
-    clearIncomingConnectionId(userId: string): Promise<void>;
-    setPendingInstallationRequest(userId: string): Promise<void>;
-    clearPendingInstallationRequest(userId: string): Promise<void>;
-    createEmailUser(data: {
-        email: string;
-        passwordHash: string;
-        displayName?: string;
-    }): Promise<schema.User>;
-    verifyEmail(userId: string): Promise<void>;
-    setEmailVerificationToken(userId: string, token: string, expires: Date): Promise<void>;
-    findByEmailVerificationToken(token: string): Promise<schema.User | null>;
-    updatePassword(userId: string, passwordHash: string): Promise<void>;
-}
-export declare const userQueries: UserQueries;
-export interface UserEmailQueries {
-    /** Find all emails for a user */
-    findByUserId(userId: string): Promise<schema.UserEmail[]>;
-    /** Find a user by any of their linked emails (for login reconciliation) */
-    findUserByEmail(email: string): Promise<schema.User | null>;
-    /** Add or update an email for a user */
-    upsert(data: {
-        userId: string;
-        email: string;
-        verified: boolean;
-        primary: boolean;
-        source?: string;
-    }): Promise<schema.UserEmail>;
-    /** Sync all emails from GitHub for a user (replaces GitHub-sourced emails) */
-    syncFromGitHub(userId: string, emails: Array<{
-        email: string;
-        verified: boolean;
-        primary: boolean;
-    }>): Promise<void>;
-    /** Delete a specific email for a user */
-    delete(userId: string, email: string): Promise<void>;
-    /** Check if an email is already linked to another user */
-    isEmailLinkedToOtherUser(email: string, excludeUserId: string): Promise<boolean>;
-}
-export declare const userEmailQueries: UserEmailQueries;
-export interface GitHubInstallationQueries {
-    findById(id: string): Promise<schema.GitHubInstallation | null>;
-    findByInstallationId(installationId: string): Promise<schema.GitHubInstallation | null>;
-    findByAccountLogin(accountLogin: string): Promise<schema.GitHubInstallation | null>;
-    findByInstalledBy(userId: string): Promise<schema.GitHubInstallation[]>;
-    findAll(): Promise<schema.GitHubInstallation[]>;
-    upsert(data: schema.NewGitHubInstallation): Promise<schema.GitHubInstallation>;
-    updatePermissions(installationId: string, permissions: Record<string, string>, events: string[]): Promise<void>;
-    suspend(installationId: string, suspendedBy: string): Promise<void>;
-    unsuspend(installationId: string): Promise<void>;
-    delete(installationId: string): Promise<void>;
-}
-export declare const githubInstallationQueries: GitHubInstallationQueries;
-export interface CredentialQueries {
-    /** Get all credentials for a user (across all workspaces) */
-    findByUserId(userId: string): Promise<schema.Credential[]>;
-    /** Get all credentials for a user in a specific workspace */
-    findByUserAndWorkspace(userId: string, workspaceId: string): Promise<schema.Credential[]>;
-    /** Get a specific provider credential for a user in a workspace */
-    findByUserWorkspaceAndProvider(userId: string, workspaceId: string, provider: string): Promise<schema.Credential | null>;
-    /** @deprecated Use findByUserWorkspaceAndProvider for workspace-scoped queries */
-    findByUserAndProvider(userId: string, provider: string): Promise<schema.Credential | null>;
-    /** Upsert credential (unique on userId + provider + workspaceId) */
-    upsert(data: schema.NewCredential): Promise<schema.Credential>;
-    /** Delete credential for a specific workspace */
-    deleteForWorkspace(userId: string, workspaceId: string, provider: string): Promise<void>;
-    /** @deprecated Use deleteForWorkspace for workspace-scoped deletions */
-    delete(userId: string, provider: string): Promise<void>;
-}
-export declare const credentialQueries: CredentialQueries;
-export interface WorkspaceQueries {
-    findById(id: string): Promise<schema.Workspace | null>;
-    findByUserId(userId: string): Promise<schema.Workspace[]>;
-    findByCustomDomain(domain: string): Promise<schema.Workspace | null>;
-    findByRepoFullName(repoFullName: string): Promise<schema.Workspace | null>;
-    findAll(): Promise<schema.Workspace[]>;
-    create(data: schema.NewWorkspace): Promise<schema.Workspace>;
-    update(id: string, data: Partial<Pick<schema.Workspace, 'name' | 'config'>>): Promise<void>;
-    updateStatus(id: string, status: string, options?: {
-        computeId?: string;
-        publicUrl?: string;
-        errorMessage?: string;
-    }): Promise<void>;
-    updateConfig(id: string, config: schema.WorkspaceConfig): Promise<void>;
-    setCustomDomain(id: string, customDomain: string, status?: string): Promise<void>;
-    updateCustomDomainStatus(id: string, status: string): Promise<void>;
-    removeCustomDomain(id: string): Promise<void>;
-    delete(id: string): Promise<void>;
-}
-export declare const workspaceQueries: WorkspaceQueries;
-export interface WorkspaceMemberQueries {
-    findByWorkspaceId(workspaceId: string): Promise<schema.WorkspaceMember[]>;
-    findByUserId(userId: string): Promise<schema.WorkspaceMember[]>;
-    findMembership(workspaceId: string, userId: string): Promise<schema.WorkspaceMember | null>;
-    addMember(data: {
-        workspaceId: string;
-        userId: string;
-        role: string;
-        invitedBy: string;
-    }): Promise<schema.WorkspaceMember>;
-    acceptInvite(workspaceId: string, userId: string): Promise<void>;
-    updateRole(workspaceId: string, userId: string, role: string): Promise<void>;
-    removeMember(workspaceId: string, userId: string): Promise<void>;
-    getPendingInvites(userId: string): Promise<schema.WorkspaceMember[]>;
-    isOwner(workspaceId: string, userId: string): Promise<boolean>;
-    canEdit(workspaceId: string, userId: string): Promise<boolean>;
-    canView(workspaceId: string, userId: string): Promise<boolean>;
-}
-export declare const workspaceMemberQueries: WorkspaceMemberQueries;
-export interface DaemonAgentInfo {
-    daemonId: string;
-    daemonName: string;
-    machineId: string;
-    agents: Array<{
-        name: string;
-        status: string;
-    }>;
-}
-export interface DaemonUpdate {
-    type: string;
-    payload: unknown;
-}
-export interface LinkedDaemonQueries {
-    findById(id: string): Promise<schema.LinkedDaemon | null>;
-    findByUserId(userId: string): Promise<schema.LinkedDaemon[]>;
-    findByWorkspaceId(workspaceId: string): Promise<schema.LinkedDaemon[]>;
-    findByMachineId(userId: string, machineId: string): Promise<schema.LinkedDaemon | null>;
-    findByApiKeyHash(apiKeyHash: string): Promise<schema.LinkedDaemon | null>;
-    create(data: schema.NewLinkedDaemon): Promise<schema.LinkedDaemon>;
-    update(id: string, data: Partial<schema.LinkedDaemon>): Promise<void>;
-    updateLastSeen(id: string): Promise<void>;
-    delete(id: string): Promise<void>;
-    markStale(): Promise<number>;
-    getAllAgentsForUser(userId: string): Promise<DaemonAgentInfo[]>;
-    getPendingUpdates(id: string): Promise<DaemonUpdate[]>;
-    queueUpdate(id: string, update: DaemonUpdate): Promise<void>;
-    queueMessage(id: string, message: Record<string, unknown>): Promise<void>;
-    getQueuedMessages(id: string): Promise<Array<Record<string, unknown>>>;
-    clearMessageQueue(id: string): Promise<void>;
-}
-export declare const linkedDaemonQueries: LinkedDaemonQueries;
-export interface ProjectGroupWithRepositories extends schema.ProjectGroup {
-    repositories: schema.Repository[];
-}
-export interface AllGroupsResult {
-    groups: ProjectGroupWithRepositories[];
-    ungroupedRepositories: schema.Repository[];
-}
-export interface ProjectGroupQueries {
-    findById(id: string): Promise<schema.ProjectGroup | null>;
-    findByUserId(userId: string): Promise<schema.ProjectGroup[]>;
-    findByName(userId: string, name: string): Promise<schema.ProjectGroup | null>;
-    create(data: schema.NewProjectGroup): Promise<schema.ProjectGroup>;
-    update(id: string, data: Partial<Omit<schema.ProjectGroup, 'id' | 'userId' | 'createdAt'>>): Promise<void>;
-    delete(id: string): Promise<void>;
-    findWithRepositories(id: string): Promise<ProjectGroupWithRepositories | null>;
-    findAllWithRepositories(userId: string): Promise<AllGroupsResult>;
-    updateCoordinatorAgent(id: string, config: schema.CoordinatorAgentConfig): Promise<void>;
-    reorder(userId: string, orderedIds: string[]): Promise<void>;
-}
-export declare const projectGroupQueries: ProjectGroupQueries;
-export interface RepositoryQueries {
-    findById(id: string): Promise<schema.Repository | null>;
-    findByFullName(fullName: string): Promise<schema.Repository | null>;
-    findByGithubFullName(fullName: string): Promise<schema.Repository[]>;
-    findByUserId(userId: string): Promise<schema.Repository[]>;
-    findByWorkspaceId(workspaceId: string): Promise<schema.Repository[]>;
-    findByProjectGroupId(projectGroupId: string): Promise<schema.Repository[]>;
-    upsert(data: schema.NewRepository): Promise<schema.Repository>;
-    assignToWorkspace(repoId: string, workspaceId: string | null): Promise<void>;
-    assignToGroup(repoId: string, projectGroupId: string | null): Promise<void>;
-    updateProjectAgent(id: string, config: schema.ProjectAgentConfig): Promise<void>;
-    updateSyncStatus(id: string, status: string, lastSyncedAt?: Date): Promise<void>;
-    delete(id: string): Promise<void>;
-}
-export declare const repositoryQueries: RepositoryQueries;
-export interface AgentSessionQueries {
-    findById(id: string): Promise<schema.AgentSession | null>;
-    findByWorkspaceId(workspaceId: string): Promise<schema.AgentSession[]>;
-    findActiveByWorkspace(workspaceId: string): Promise<schema.AgentSession[]>;
-    create(data: schema.NewAgentSession): Promise<schema.AgentSession>;
-    endSession(id: string, endMarker?: {
-        summary?: string;
-        completedTasks?: string[];
-    }): Promise<void>;
-    delete(id: string): Promise<void>;
-}
-export declare const agentSessionQueries: AgentSessionQueries;
-export interface AgentSummaryQueries {
-    findBySessionId(sessionId: string): Promise<schema.AgentSummary[]>;
-    findLatestByAgent(agentName: string): Promise<schema.AgentSummary | null>;
-    create(data: schema.NewAgentSummary): Promise<schema.AgentSummary>;
-    deleteBySession(sessionId: string): Promise<void>;
-}
-export declare const agentSummaryQueries: AgentSummaryQueries;
-export interface CIFailureEventQueries {
-    findById(id: string): Promise<schema.CIFailureEvent | null>;
-    findByRepository(repository: string, limit?: number): Promise<schema.CIFailureEvent[]>;
-    findByPR(repository: string, prNumber: number): Promise<schema.CIFailureEvent[]>;
-    findRecentUnprocessed(limit?: number): Promise<schema.CIFailureEvent[]>;
-    create(data: schema.NewCIFailureEvent): Promise<schema.CIFailureEvent>;
-    markProcessed(id: string, agentSpawned: boolean): Promise<void>;
-    delete(id: string): Promise<void>;
-}
-export declare const ciFailureEventQueries: CIFailureEventQueries;
-export interface CIFixAttemptQueries {
-    findById(id: string): Promise<schema.CIFixAttempt | null>;
-    findByFailureEvent(failureEventId: string): Promise<schema.CIFixAttempt[]>;
-    findActiveByRepository(repository: string): Promise<schema.CIFixAttempt[]>;
-    create(data: schema.NewCIFixAttempt): Promise<schema.CIFixAttempt>;
-    updateStatus(id: string, status: string, errorMessage?: string): Promise<void>;
-    complete(id: string, status: 'success' | 'failed', commitSha?: string, errorMessage?: string): Promise<void>;
-}
-export declare const ciFixAttemptQueries: CIFixAttemptQueries;
-export interface IssueAssignmentQueries {
-    findById(id: string): Promise<schema.IssueAssignment | null>;
-    findByRepository(repository: string, limit?: number): Promise<schema.IssueAssignment[]>;
-    findByIssue(repository: string, issueNumber: number): Promise<schema.IssueAssignment | null>;
-    findByAgent(agentId: string): Promise<schema.IssueAssignment[]>;
-    findPending(limit?: number): Promise<schema.IssueAssignment[]>;
-    create(data: schema.NewIssueAssignment): Promise<schema.IssueAssignment>;
-    assignAgent(id: string, agentId: string, agentName: string): Promise<void>;
-    updateStatus(id: string, status: string, resolution?: string): Promise<void>;
-    linkPR(id: string, prNumber: number): Promise<void>;
-}
-export declare const issueAssignmentQueries: IssueAssignmentQueries;
-export interface CommentMentionQueries {
-    findById(id: string): Promise<schema.CommentMention | null>;
-    findByRepository(repository: string, limit?: number): Promise<schema.CommentMention[]>;
-    findBySource(sourceType: string, sourceId: number): Promise<schema.CommentMention | null>;
-    findPending(limit?: number): Promise<schema.CommentMention[]>;
-    findByMentionedAgent(mentionedAgent: string, limit?: number): Promise<schema.CommentMention[]>;
-    create(data: schema.NewCommentMention): Promise<schema.CommentMention>;
-    markProcessing(id: string, agentId: string, agentName: string): Promise<void>;
-    markResponded(id: string, responseCommentId: number, responseBody: string): Promise<void>;
-    markIgnored(id: string): Promise<void>;
-}
-export declare const commentMentionQueries: CommentMentionQueries;
-export interface ChannelQueries {
-    findById(id: string): Promise<schema.Channel | null>;
-    findByWorkspaceId(workspaceId: string): Promise<schema.Channel[]>;
-    findByWorkspaceAndChannelId(workspaceId: string, channelId: string): Promise<schema.Channel | null>;
-    create(channel: schema.NewChannel): Promise<schema.Channel>;
-    update(id: string, updates: Partial<schema.NewChannel>): Promise<void>;
-    archive(id: string): Promise<void>;
-    unarchive(id: string): Promise<void>;
-    delete(id: string): Promise<void>;
-}
-export declare const channelQueries: ChannelQueries;
-export interface ChannelMemberQueries {
-    findByChannelId(channelId: string): Promise<schema.ChannelMember[]>;
-    findByMemberId(memberId: string): Promise<schema.ChannelMember[]>;
-    findMembership(channelId: string, memberId: string): Promise<schema.ChannelMember | null>;
-    addMember(member: schema.NewChannelMember): Promise<schema.ChannelMember>;
-    removeMember(channelId: string, memberId: string): Promise<void>;
-    updateRole(channelId: string, memberId: string, role: string): Promise<void>;
-    countByChannelIds(channelIds: string[]): Promise<Map<string, number>>;
-}
-export declare const channelMemberQueries: ChannelMemberQueries;
-export declare function runMigrations(): Promise<void>;
-export declare function closeDb(): Promise<void>;
-//# sourceMappingURL=drizzle.d.ts.map