agent-relay 1.6.0 → 2.0.0

package/dist/cloud/billing/plans.js

@@ -1,245 +0,0 @@
-/**
- * Agent Relay Cloud - Billing Plans
- *
- * Plan definitions for subscription tiers.
- */
-/**
- * All available billing plans
- */
-export const BILLING_PLANS = {
-    free: {
-        id: 'free',
-        name: 'Free',
-        description: 'Try AI agent workflows with limited access',
-        priceMonthly: 0,
-        priceYearly: 0,
-        limits: {
-            maxWorkspaces: 1,
-            maxAgentsPerWorkspace: 2,
-            maxTeamMembers: 1,
-            maxStorageGB: 1,
-            maxComputeHoursPerMonth: 5, // Limited to 5 hours/month
-            customDomains: false,
-            prioritySupport: false,
-            sla: false,
-            ssoEnabled: false,
-            auditLogs: false,
-            sessionPersistence: false,
-        },
-        features: [
-            '1 workspace',
-            'Up to 2 agents',
-            '5 compute hours/month',
-            'Shared CPU (may throttle)',
-            'Community support',
-        ],
-    },
-    pro: {
-        id: 'pro',
-        name: 'Pro',
-        description: 'For professional developers building with AI agents',
-        priceMonthly: 4900, // $49/month
-        priceYearly: 47000, // $470/year (2 months free)
-        stripePriceIdMonthly: process.env.STRIPE_PRO_MONTHLY_PRICE_ID,
-        stripePriceIdYearly: process.env.STRIPE_PRO_YEARLY_PRICE_ID,
-        limits: {
-            maxWorkspaces: 5,
-            maxAgentsPerWorkspace: 5,
-            maxTeamMembers: 3,
-            maxStorageGB: 10,
-            maxComputeHoursPerMonth: 50,
-            customDomains: true,
-            prioritySupport: false,
-            sla: false,
-            ssoEnabled: false,
-            auditLogs: false,
-            sessionPersistence: true,
-        },
-        features: [
-            'Up to 5 workspaces',
-            'Up to 5 agents per workspace',
-            '50 compute hours/month',
-            '10 GB storage',
-            '3 team members',
-            'Custom domains',
-            'Session persistence',
-            'Email support',
-        ],
-    },
-    team: {
-        id: 'team',
-        name: 'Team',
-        description: 'For growing teams with advanced needs',
-        priceMonthly: 9900, // $99/month
-        priceYearly: 99000, // $990/year (2 months free)
-        stripePriceIdMonthly: process.env.STRIPE_TEAM_MONTHLY_PRICE_ID,
-        stripePriceIdYearly: process.env.STRIPE_TEAM_YEARLY_PRICE_ID,
-        limits: {
-            maxWorkspaces: 50,
-            maxAgentsPerWorkspace: 25,
-            maxTeamMembers: 25,
-            maxStorageGB: 50,
-            maxComputeHoursPerMonth: 500,
-            customDomains: true,
-            prioritySupport: true,
-            sla: false,
-            ssoEnabled: false,
-            auditLogs: true,
-            sessionPersistence: true,
-        },
-        features: [
-            'Up to 50 workspaces',
-            'Up to 25 agents per workspace',
-            '500 compute hours/month',
-            '50 GB storage',
-            '25 team members',
-            'Custom domains',
-            'Session persistence',
-            'Priority support',
-            'Audit logs',
-        ],
-    },
-    enterprise: {
-        id: 'enterprise',
-        name: 'Enterprise',
-        description: 'For organizations requiring dedicated support and SLAs',
-        priceMonthly: 49900, // $499/month starting
-        priceYearly: 499000, // $4990/year
-        stripePriceIdMonthly: process.env.STRIPE_ENTERPRISE_MONTHLY_PRICE_ID,
-        stripePriceIdYearly: process.env.STRIPE_ENTERPRISE_YEARLY_PRICE_ID,
-        limits: {
-            maxWorkspaces: -1, // unlimited
-            maxAgentsPerWorkspace: -1, // unlimited
-            maxTeamMembers: -1, // unlimited
-            maxStorageGB: 500,
-            maxComputeHoursPerMonth: -1, // unlimited
-            customDomains: true,
-            prioritySupport: true,
-            sla: true,
-            ssoEnabled: true,
-            auditLogs: true,
-            sessionPersistence: true,
-        },
-        features: [
-            'Unlimited workspaces',
-            'Unlimited agents',
-            'Unlimited compute hours',
-            '500 GB storage',
-            'Unlimited team members',
-            'Custom domains',
-            'Session persistence',
-            'Priority support with SLA',
-            'SSO/SAML integration',
-            'Audit logs & compliance',
-            'Dedicated account manager',
-        ],
-    },
-};
-/**
- * Get plan by ID
- */
-export function getPlan(tier) {
-    return BILLING_PLANS[tier];
-}
-/**
- * Get all plans as array
- */
-export function getAllPlans() {
-    return Object.values(BILLING_PLANS);
-}
-/**
- * Check if a limit is within plan bounds
- * Returns true if the value is within limits (-1 means unlimited)
- */
-export function isWithinLimit(limit, current) {
-    if (limit === -1)
-        return true; // unlimited
-    return current < limit;
-}
-/**
- * Get the next tier upgrade from current
- */
-export function getUpgradeTier(current) {
-    const tiers = ['free', 'pro', 'team', 'enterprise'];
-    const currentIndex = tiers.indexOf(current);
-    if (currentIndex === -1 || currentIndex >= tiers.length - 1) {
-        return null;
-    }
-    return tiers[currentIndex + 1];
-}
-/**
- * Format price for display
- */
-export function formatPrice(cents) {
-    if (cents === 0)
-        return 'Free';
-    return `$${(cents / 100).toFixed(0)}`;
-}
-/**
- * Get plan limits comparison
- */
-export function comparePlans(from, to) {
-    const fromPlan = BILLING_PLANS[from];
-    const toPlan = BILLING_PLANS[to];
-    const upgrades = [];
-    const downgrades = [];
-    // Compare limits
-    const compareLimit = (name, fromVal, toVal) => {
-        if (toVal === -1 && fromVal !== -1) {
-            upgrades.push(`Unlimited ${name}`);
-        }
-        else if (fromVal === -1 && toVal !== -1) {
-            downgrades.push(`${name} limited to ${toVal}`);
-        }
-        else if (toVal > fromVal) {
-            upgrades.push(`${name}: ${fromVal} -> ${toVal}`);
-        }
-        else if (toVal < fromVal) {
-            downgrades.push(`${name}: ${fromVal} -> ${toVal}`);
-        }
-    };
-    compareLimit('workspaces', fromPlan.limits.maxWorkspaces, toPlan.limits.maxWorkspaces);
-    compareLimit('agents per workspace', fromPlan.limits.maxAgentsPerWorkspace, toPlan.limits.maxAgentsPerWorkspace);
-    compareLimit('team members', fromPlan.limits.maxTeamMembers, toPlan.limits.maxTeamMembers);
-    compareLimit('storage GB', fromPlan.limits.maxStorageGB, toPlan.limits.maxStorageGB);
-    compareLimit('compute hours', fromPlan.limits.maxComputeHoursPerMonth, toPlan.limits.maxComputeHoursPerMonth);
-    // Compare boolean features
-    if (toPlan.limits.customDomains && !fromPlan.limits.customDomains) {
-        upgrades.push('Custom domains');
-    }
-    else if (!toPlan.limits.customDomains && fromPlan.limits.customDomains) {
-        downgrades.push('Custom domains');
-    }
-    if (toPlan.limits.prioritySupport && !fromPlan.limits.prioritySupport) {
-        upgrades.push('Priority support');
-    }
-    else if (!toPlan.limits.prioritySupport && fromPlan.limits.prioritySupport) {
-        downgrades.push('Priority support');
-    }
-    if (toPlan.limits.sla && !fromPlan.limits.sla) {
-        upgrades.push('SLA');
-    }
-    else if (!toPlan.limits.sla && fromPlan.limits.sla) {
-        downgrades.push('SLA');
-    }
-    if (toPlan.limits.ssoEnabled && !fromPlan.limits.ssoEnabled) {
-        upgrades.push('SSO/SAML');
-    }
-    else if (!toPlan.limits.ssoEnabled && fromPlan.limits.ssoEnabled) {
-        downgrades.push('SSO/SAML');
-    }
-    if (toPlan.limits.auditLogs && !fromPlan.limits.auditLogs) {
-        upgrades.push('Audit logs');
-    }
-    else if (!toPlan.limits.auditLogs && fromPlan.limits.auditLogs) {
-        downgrades.push('Audit logs');
-    }
-    if (toPlan.limits.sessionPersistence && !fromPlan.limits.sessionPersistence) {
-        upgrades.push('Session persistence');
-    }
-    else if (!toPlan.limits.sessionPersistence && fromPlan.limits.sessionPersistence) {
-        downgrades.push('Session persistence');
-    }
-    return { upgrades, downgrades };
-}
-//# sourceMappingURL=plans.js.map

package/dist/cloud/config.d.ts

@@ -1,75 +0,0 @@
-/**
- * Agent Relay Cloud - Configuration
- */
-export interface CloudConfig {
-    port: number;
-    publicUrl: string;
-    appUrl: string;
-    sessionSecret: string;
-    localDashboardUrl?: string;
-    databaseUrl: string;
-    redisUrl: string;
-    github: {
-        clientId: string;
-        clientSecret: string;
-        webhookSecret?: string;
-    };
-    providers: {
-        anthropic?: {
-            clientId: string;
-        };
-        openai?: {
-            clientId: string;
-        };
-        google?: {
-            clientId: string;
-            clientSecret: string;
-        };
-    };
-    vault: {
-        masterKey: string;
-    };
-    compute: {
-        provider: 'fly' | 'railway' | 'docker';
-        fly?: {
-            apiToken: string;
-            org: string;
-            region?: string;
-            workspaceDomain?: string;
-            registryAuth?: {
-                username: string;
-                password: string;
-            };
-            snapshotRetentionDays?: number;
-            volumeSizeGb?: number;
-        };
-        railway?: {
-            apiToken: string;
-        };
-    };
-    nango: {
-        secretKey: string;
-        host?: string;
-    };
-    stripe: {
-        secretKey: string;
-        publishableKey: string;
-        webhookSecret: string;
-        priceIds: {
-            proMonthly?: string;
-            proYearly?: string;
-            teamMonthly?: string;
-            teamYearly?: string;
-            enterpriseMonthly?: string;
-            enterpriseYearly?: string;
-        };
-    };
-    adminUsers: string[];
-}
-export declare function loadConfig(): CloudConfig;
-/**
- * Check if a GitHub username is an admin user
- */
-export declare function isAdminUser(githubUsername: string): boolean;
-export declare function getConfig(): CloudConfig;
-//# sourceMappingURL=config.d.ts.map

package/dist/cloud/config.js

@@ -1,109 +0,0 @@
-/**
- * Agent Relay Cloud - Configuration
- */
-function requireEnv(name) {
-    const value = process.env[name];
-    if (!value) {
-        throw new Error(`Missing required environment variable: ${name}`);
-    }
-    return value;
-}
-function optionalEnv(name) {
-    return process.env[name];
-}
-export function loadConfig() {
-    return {
-        port: parseInt(process.env.PORT || '4567', 10),
-        publicUrl: process.env.PUBLIC_URL || 'http://localhost:4567',
-        appUrl: process.env.APP_URL || process.env.PUBLIC_URL || 'http://localhost:4567',
-        sessionSecret: requireEnv('SESSION_SECRET'),
-        // Local dashboard for channel API (auto-detected if not set)
-        localDashboardUrl: optionalEnv('LOCAL_DASHBOARD_URL'),
-        databaseUrl: requireEnv('DATABASE_URL'),
-        redisUrl: process.env.REDIS_URL || 'redis://localhost:6379',
-        github: {
-            clientId: requireEnv('GITHUB_CLIENT_ID'),
-            clientSecret: requireEnv('GITHUB_CLIENT_SECRET'),
-            webhookSecret: optionalEnv('GITHUB_WEBHOOK_SECRET'),
-        },
-        providers: {
-            anthropic: optionalEnv('ANTHROPIC_CLIENT_ID')
-                ? { clientId: optionalEnv('ANTHROPIC_CLIENT_ID') }
-                : undefined,
-            openai: optionalEnv('OPENAI_CLIENT_ID')
-                ? { clientId: optionalEnv('OPENAI_CLIENT_ID') }
-                : undefined,
-            google: optionalEnv('GOOGLE_CLIENT_ID') && optionalEnv('GOOGLE_CLIENT_SECRET')
-                ? {
-                    clientId: optionalEnv('GOOGLE_CLIENT_ID'),
-                    clientSecret: optionalEnv('GOOGLE_CLIENT_SECRET'),
-                }
-                : undefined,
-        },
-        vault: {
-            masterKey: requireEnv('VAULT_MASTER_KEY'),
-        },
-        compute: {
-            provider: process.env.COMPUTE_PROVIDER || 'docker',
-            fly: optionalEnv('FLY_API_TOKEN')
-                ? {
-                    apiToken: optionalEnv('FLY_API_TOKEN'),
-                    org: optionalEnv('FLY_ORG') || 'personal',
-                    region: optionalEnv('FLY_REGION') || 'sjc',
-                    workspaceDomain: optionalEnv('FLY_WORKSPACE_DOMAIN'),
-                    registryAuth: optionalEnv('GHCR_USERNAME') && optionalEnv('GHCR_TOKEN')
-                        ? {
-                            username: optionalEnv('GHCR_USERNAME'),
-                            password: optionalEnv('GHCR_TOKEN'),
-                        }
-                        : undefined,
-                    snapshotRetentionDays: parseInt(optionalEnv('FLY_SNAPSHOT_RETENTION_DAYS') || '14', 10),
-                    volumeSizeGb: parseInt(optionalEnv('FLY_VOLUME_SIZE_GB') || '10', 10),
-                }
-                : undefined,
-            railway: optionalEnv('RAILWAY_API_TOKEN')
-                ? {
-                    apiToken: optionalEnv('RAILWAY_API_TOKEN'),
-                }
-                : undefined,
-        },
-        nango: {
-            secretKey: requireEnv('NANGO_SECRET_KEY'),
-            host: optionalEnv('NANGO_HOST'),
-        },
-        stripe: {
-            secretKey: requireEnv('STRIPE_SECRET_KEY'),
-            publishableKey: requireEnv('STRIPE_PUBLISHABLE_KEY'),
-            webhookSecret: requireEnv('STRIPE_WEBHOOK_SECRET'),
-            priceIds: {
-                proMonthly: optionalEnv('STRIPE_PRO_MONTHLY_PRICE_ID'),
-                proYearly: optionalEnv('STRIPE_PRO_YEARLY_PRICE_ID'),
-                teamMonthly: optionalEnv('STRIPE_TEAM_MONTHLY_PRICE_ID'),
-                teamYearly: optionalEnv('STRIPE_TEAM_YEARLY_PRICE_ID'),
-                enterpriseMonthly: optionalEnv('STRIPE_ENTERPRISE_MONTHLY_PRICE_ID'),
-                enterpriseYearly: optionalEnv('STRIPE_ENTERPRISE_YEARLY_PRICE_ID'),
-            },
-        },
-        // Admin users - comma-separated GitHub usernames (e.g., "khaliqgant,admin2")
-        adminUsers: (optionalEnv('ADMIN_USERS') || '')
-            .split(',')
-            .map((u) => u.trim().toLowerCase())
-            .filter(Boolean),
-    };
-}
-/**
- * Check if a GitHub username is an admin user
- */
-export function isAdminUser(githubUsername) {
-    const config = getConfig();
-    return config.adminUsers.includes(githubUsername.toLowerCase());
-}
-// Singleton config instance
-let _config = null;
-export function getConfig() {
-    if (!_config) {
-        _config = loadConfig();
-    }
-    return _config;
-}
-//# sourceMappingURL=config.js.map

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

@@ -1,246 +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, 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>;
-}
-export declare const userQueries: UserQueries;
-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 {
-    findByUserId(userId: string): Promise<schema.Credential[]>;
-    findByUserAndProvider(userId: string, provider: string): Promise<schema.Credential | null>;
-    upsert(data: schema.NewCredential): Promise<schema.Credential>;
-    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