agent-relay 1.6.0 → 2.0.0

package/packages/cloud/dist/services/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Cloud Services Index
+ *
+ * Exports all cloud-side services for easy importing.
+ */
+export { ScalingPolicyService, type ScalingThresholds, type ScalingPolicy, type ScalingCondition, type ScalingAction, type ScalingDecision, type UserScalingContext, type WorkspaceMetrics, getScalingPolicyService, } from './scaling-policy.js';
+export { AutoScaler, type AutoScalerConfig, type ScalingOperation, type MetricsSnapshot, getAutoScaler, createAutoScaler, } from './auto-scaler.js';
+export { CapacityManager, type CapacityManagerConfig, type WorkspaceCapacity, type PlacementRecommendation, type CapacitySnapshot, type CapacityForecast, getCapacityManager, createCapacityManager, } from './capacity-manager.js';
+export { ScalingOrchestrator, type OrchestratorConfig, type ScalingEvent, getScalingOrchestrator, createScalingOrchestrator, } from './scaling-orchestrator.js';
+export { spawnCIFixAgent, notifyAgentOfCIFailure, completeFixAttempt, getFailureHistory, getPRFailureHistory, } from './ci-agent-spawner.js';
+export { handleMention, handleIssueAssignment, getPendingMentions, getPendingIssueAssignments, processPendingMentions, processPendingIssueAssignments, KNOWN_AGENTS, isKnownAgent, } from './mention-handler.js';
+export { ComputeEnforcementService, type ComputeEnforcementConfig, type EnforcementResult, getComputeEnforcementService, createComputeEnforcementService, } from './compute-enforcement.js';
+export { IntroExpirationService, type IntroExpirationConfig, type IntroStatus, type ExpirationResult as IntroExpirationResult, INTRO_PERIOD_DAYS, DESTROY_GRACE_PERIOD_DAYS, getIntroStatus, getIntroExpirationService, startIntroExpirationService, stopIntroExpirationService, } from './intro-expiration.js';
+export { WorkspaceKeepaliveService, type WorkspaceKeepaliveConfig, type KeepaliveStats, getWorkspaceKeepaliveService, createWorkspaceKeepaliveService, } from './workspace-keepalive.js';
+export { registerUserPresence, unregisterUserPresence, updateUserLastSeen, isUserOnline, getOnlineUser, getOnlineUsers, getOnlineUsersForDiscovery, clearAllPresence, type PresenceUserInfo, } from './presence-registry.js';
+export { cloudMessageBus, type CloudMessage, } from './cloud-message-bus.js';
+//# sourceMappingURL=index.d.ts.map

package/packages/cloud/dist/services/index.js

@@ -0,0 +1,25 @@
+/**
+ * Cloud Services Index
+ *
+ * Exports all cloud-side services for easy importing.
+ */
+// Scaling infrastructure
+export { ScalingPolicyService, getScalingPolicyService, } from './scaling-policy.js';
+export { AutoScaler, getAutoScaler, createAutoScaler, } from './auto-scaler.js';
+export { CapacityManager, getCapacityManager, createCapacityManager, } from './capacity-manager.js';
+export { ScalingOrchestrator, getScalingOrchestrator, createScalingOrchestrator, } from './scaling-orchestrator.js';
+// CI failure handling
+export { spawnCIFixAgent, notifyAgentOfCIFailure, completeFixAttempt, getFailureHistory, getPRFailureHistory, } from './ci-agent-spawner.js';
+// Issue and mention handling
+export { handleMention, handleIssueAssignment, getPendingMentions, getPendingIssueAssignments, processPendingMentions, processPendingIssueAssignments, KNOWN_AGENTS, isKnownAgent, } from './mention-handler.js';
+// Compute enforcement (free tier limits)
+export { ComputeEnforcementService, getComputeEnforcementService, createComputeEnforcementService, } from './compute-enforcement.js';
+// Intro expiration (auto-resize/destroy after free tier intro period)
+export { IntroExpirationService, INTRO_PERIOD_DAYS, DESTROY_GRACE_PERIOD_DAYS, getIntroStatus, getIntroExpirationService, startIntroExpirationService, stopIntroExpirationService, } from './intro-expiration.js';
+// Workspace keepalive (prevent Fly.io from idling machines with active agents)
+export { WorkspaceKeepaliveService, getWorkspaceKeepaliveService, createWorkspaceKeepaliveService, } from './workspace-keepalive.js';
+// Presence registry (shared registry for tracking online users)
+export { registerUserPresence, unregisterUserPresence, updateUserLastSeen, isUserOnline, getOnlineUser, getOnlineUsers, getOnlineUsersForDiscovery, clearAllPresence, } from './presence-registry.js';
+// Cloud message bus (event-based message delivery for cloud users)
+export { cloudMessageBus, } from './cloud-message-bus.js';
+//# sourceMappingURL=index.js.map

package/packages/cloud/dist/services/intro-expiration.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Intro Expiration Service
+ *
+ * Handles auto-resize and auto-destroy of free tier workspaces:
+ * 1. Resize: Free users get Pro-level resources (2 CPU / 4GB) for the first 14 days,
+ *    then get automatically downsized to standard free tier (1 CPU / 2GB).
+ * 2. Destroy: Free workspaces inactive for 7+ days after intro expires get auto-destroyed
+ *    to prevent ongoing infrastructure costs for churned users.
+ */
+export declare const INTRO_PERIOD_DAYS = 14;
+export declare const DESTROY_GRACE_PERIOD_DAYS = 7;
+export interface IntroExpirationConfig {
+    enabled: boolean;
+    checkIntervalMs: number;
+}
+export interface IntroStatus {
+    isIntroPeriod: boolean;
+    daysRemaining: number;
+    introPeriodDays: number;
+    expiresAt: Date | null;
+}
+export interface ExpirationResult {
+    userId: string;
+    workspaceId: string;
+    workspaceName: string;
+    action: 'resized' | 'destroyed' | 'skipped' | 'error';
+    reason?: string;
+}
+/**
+ * Get intro period status for a user
+ */
+export declare function getIntroStatus(userCreatedAt: Date | string | null, plan: string): IntroStatus;
+export declare class IntroExpirationService {
+    private config;
+    private checkTimer;
+    private isRunning;
+    constructor(config?: Partial<IntroExpirationConfig>);
+    /**
+     * Start the expiration service
+     */
+    start(): void;
+    /**
+     * Stop the expiration service
+     */
+    stop(): void;
+    /**
+     * Run expiration check for all free tier users with expired intro periods
+     */
+    runExpirationCheck(): Promise<ExpirationResult[]>;
+    /**
+     * Check and process workspaces for a user whose intro period has expired
+     * - Resize workspaces that are still at intro-tier resources
+     * - Destroy workspaces that have been inactive for DESTROY_GRACE_PERIOD_DAYS
+     */
+    private checkAndProcessUserWorkspaces;
+}
+export declare function getIntroExpirationService(): IntroExpirationService;
+export declare function startIntroExpirationService(): void;
+export declare function stopIntroExpirationService(): void;
+//# sourceMappingURL=intro-expiration.d.ts.map

package/packages/cloud/dist/services/intro-expiration.js

@@ -0,0 +1,252 @@
+/**
+ * Intro Expiration Service
+ *
+ * Handles auto-resize and auto-destroy of free tier workspaces:
+ * 1. Resize: Free users get Pro-level resources (2 CPU / 4GB) for the first 14 days,
+ *    then get automatically downsized to standard free tier (1 CPU / 2GB).
+ * 2. Destroy: Free workspaces inactive for 7+ days after intro expires get auto-destroyed
+ *    to prevent ongoing infrastructure costs for churned users.
+ */
+import { db } from '../db/index.js';
+import { getProvisioner } from '../provisioner/index.js';
+export const INTRO_PERIOD_DAYS = 14;
+export const DESTROY_GRACE_PERIOD_DAYS = 7; // Days of inactivity after intro before auto-destroy
+const DEFAULT_CONFIG = {
+    enabled: true,
+    checkIntervalMs: 60 * 60 * 1000, // 1 hour
+};
+/**
+ * Get intro period status for a user
+ */
+export function getIntroStatus(userCreatedAt, plan) {
+    const introPeriodDays = INTRO_PERIOD_DAYS;
+    // Only free tier users get intro bonus
+    if (plan !== 'free' || !userCreatedAt) {
+        return {
+            isIntroPeriod: false,
+            daysRemaining: 0,
+            introPeriodDays,
+            expiresAt: null,
+        };
+    }
+    const createdAt = typeof userCreatedAt === 'string' ? new Date(userCreatedAt) : userCreatedAt;
+    const daysSinceSignup = (Date.now() - createdAt.getTime()) / (1000 * 60 * 60 * 24);
+    const isIntroPeriod = daysSinceSignup < introPeriodDays;
+    const daysRemaining = Math.max(0, Math.ceil(introPeriodDays - daysSinceSignup));
+    const expiresAt = new Date(createdAt.getTime() + introPeriodDays * 24 * 60 * 60 * 1000);
+    return {
+        isIntroPeriod,
+        daysRemaining,
+        introPeriodDays,
+        expiresAt,
+    };
+}
+export class IntroExpirationService {
+    config;
+    checkTimer = null;
+    isRunning = false;
+    constructor(config = {}) {
+        this.config = { ...DEFAULT_CONFIG, ...config };
+    }
+    /**
+     * Start the expiration service
+     */
+    start() {
+        if (!this.config.enabled) {
+            console.log('[intro-expiration] Service disabled');
+            return;
+        }
+        if (this.isRunning) {
+            console.warn('[intro-expiration] Service already running');
+            return;
+        }
+        this.isRunning = true;
+        console.log(`[intro-expiration] Started (checking every ${this.config.checkIntervalMs / 1000 / 60} minutes)`);
+        // Run immediately on start
+        this.runExpirationCheck().catch((err) => {
+            console.error('[intro-expiration] Initial run failed:', err);
+        });
+        // Then run periodically
+        this.checkTimer = setInterval(() => {
+            this.runExpirationCheck().catch((err) => {
+                console.error('[intro-expiration] Periodic run failed:', err);
+            });
+        }, this.config.checkIntervalMs);
+    }
+    /**
+     * Stop the expiration service
+     */
+    stop() {
+        if (this.checkTimer) {
+            clearInterval(this.checkTimer);
+            this.checkTimer = null;
+        }
+        this.isRunning = false;
+        console.log('[intro-expiration] Stopped');
+    }
+    /**
+     * Run expiration check for all free tier users with expired intro periods
+     */
+    async runExpirationCheck() {
+        const results = [];
+        try {
+            // Get all users on free tier
+            const freeUsers = await db.users.findByPlan('free');
+            // Filter to users whose intro period has expired
+            const expiredUsers = freeUsers.filter((user) => {
+                const status = getIntroStatus(user.createdAt, user.plan || 'free');
+                return !status.isIntroPeriod && status.expiresAt !== null;
+            });
+            if (expiredUsers.length === 0) {
+                return results;
+            }
+            console.log(`[intro-expiration] Checking ${expiredUsers.length} users with expired intro periods`);
+            for (const user of expiredUsers) {
+                try {
+                    const userResults = await this.checkAndProcessUserWorkspaces(user.id, user.createdAt);
+                    results.push(...userResults);
+                }
+                catch (err) {
+                    console.error(`[intro-expiration] Error checking user ${user.id}:`, err);
+                }
+            }
+            // Summary
+            const resized = results.filter((r) => r.action === 'resized').length;
+            const destroyed = results.filter((r) => r.action === 'destroyed').length;
+            const skipped = results.filter((r) => r.action === 'skipped').length;
+            const errors = results.filter((r) => r.action === 'error').length;
+            if (resized > 0 || destroyed > 0 || errors > 0) {
+                console.log(`[intro-expiration] Results: ${resized} resized, ${destroyed} destroyed, ${skipped} skipped, ${errors} errors`);
+            }
+            return results;
+        }
+        catch (err) {
+            console.error('[intro-expiration] Run failed:', err);
+            return results;
+        }
+    }
+    /**
+     * Check and process workspaces for a user whose intro period has expired
+     * - Resize workspaces that are still at intro-tier resources
+     * - Destroy workspaces that have been inactive for DESTROY_GRACE_PERIOD_DAYS
+     */
+    async checkAndProcessUserWorkspaces(userId, userCreatedAt) {
+        const results = [];
+        const provisioner = getProvisioner();
+        // Get user's workspaces
+        const workspaces = await db.workspaces.findByUserId(userId);
+        // Calculate when intro period expired for this user
+        const introExpiredAt = new Date(userCreatedAt.getTime() + INTRO_PERIOD_DAYS * 24 * 60 * 60 * 1000);
+        const destroyThreshold = new Date(introExpiredAt.getTime() + DESTROY_GRACE_PERIOD_DAYS * 24 * 60 * 60 * 1000);
+        const now = new Date();
+        for (const workspace of workspaces) {
+            try {
+                // Check if workspace has intro-sized resources
+                const config = workspace.config;
+                const resourceTier = config?.resourceTier;
+                // Check last activity via linked daemons
+                const daemons = await db.linkedDaemons.findByWorkspaceId(workspace.id);
+                const lastActivity = daemons.length > 0
+                    ? daemons.reduce((latest, d) => {
+                        const seen = d.lastSeenAt ? new Date(d.lastSeenAt) : new Date(0);
+                        return seen > latest ? seen : latest;
+                    }, new Date(0))
+                    : workspace.updatedAt; // Fall back to workspace updatedAt
+                // Check if workspace should be destroyed (inactive for grace period after intro)
+                const daysSinceActivity = (now.getTime() - lastActivity.getTime()) / (1000 * 60 * 60 * 24);
+                const shouldDestroy = now > destroyThreshold && daysSinceActivity >= DESTROY_GRACE_PERIOD_DAYS;
+                if (shouldDestroy) {
+                    console.log(`[intro-expiration] Destroying inactive free workspace ${workspace.name} (${daysSinceActivity.toFixed(1)} days inactive)`);
+                    try {
+                        await provisioner.deprovision(workspace.id);
+                        results.push({
+                            userId,
+                            workspaceId: workspace.id,
+                            workspaceName: workspace.name,
+                            action: 'destroyed',
+                            reason: `Inactive for ${Math.round(daysSinceActivity)} days after intro period expired`,
+                        });
+                    }
+                    catch (deprovisionErr) {
+                        console.error(`[intro-expiration] Failed to destroy workspace ${workspace.id}:`, deprovisionErr);
+                        results.push({
+                            userId,
+                            workspaceId: workspace.id,
+                            workspaceName: workspace.name,
+                            action: 'error',
+                            reason: `Failed to destroy: ${deprovisionErr instanceof Error ? deprovisionErr.message : 'Unknown error'}`,
+                        });
+                    }
+                    continue;
+                }
+                // Skip resize if already at standard free tier
+                if (resourceTier === 'small') {
+                    results.push({
+                        userId,
+                        workspaceId: workspace.id,
+                        workspaceName: workspace.name,
+                        action: 'skipped',
+                        reason: 'Already at standard free tier size',
+                    });
+                    continue;
+                }
+                // Skip if workspace is not running (resize happens on next start)
+                if (workspace.status !== 'running') {
+                    results.push({
+                        userId,
+                        workspaceId: workspace.id,
+                        workspaceName: workspace.name,
+                        action: 'skipped',
+                        reason: `Workspace status is ${workspace.status}`,
+                    });
+                    continue;
+                }
+                // Resize to standard free tier (small: 2 CPU / 2GB)
+                // Use skipRestart=true to not disrupt running agents
+                console.log(`[intro-expiration] Resizing workspace ${workspace.name} to standard free tier`);
+                await provisioner.resize(workspace.id, {
+                    name: 'small',
+                    cpuCores: 2,
+                    cpuKind: 'shared',
+                    memoryMb: 2048,
+                    maxAgents: 2,
+                }, true); // skipRestart = true for graceful resize
+                results.push({
+                    userId,
+                    workspaceId: workspace.id,
+                    workspaceName: workspace.name,
+                    action: 'resized',
+                    reason: 'Intro period expired, downsized to standard free tier (applies on next restart)',
+                });
+            }
+            catch (err) {
+                console.error(`[intro-expiration] Failed to process workspace ${workspace.id}:`, err);
+                results.push({
+                    userId,
+                    workspaceId: workspace.id,
+                    workspaceName: workspace.name,
+                    action: 'error',
+                    reason: err instanceof Error ? err.message : 'Unknown error',
+                });
+            }
+        }
+        return results;
+    }
+}
+// Singleton instance
+let _service = null;
+export function getIntroExpirationService() {
+    if (!_service) {
+        _service = new IntroExpirationService();
+    }
+    return _service;
+}
+export function startIntroExpirationService() {
+    getIntroExpirationService().start();
+}
+export function stopIntroExpirationService() {
+    if (_service) {
+        _service.stop();
+    }
+}
+//# sourceMappingURL=intro-expiration.js.map

package/packages/cloud/dist/services/nango.d.ts

@@ -0,0 +1,201 @@
+export declare const NANGO_INTEGRATIONS: {
+    readonly GITHUB_USER: "github";
+    readonly GITHUB_APP: "github-app-oauth";
+};
+export interface GithubUserProfile {
+    id: number;
+    login: string;
+    email?: string;
+    avatar_url?: string;
+}
+declare class NangoService {
+    private _client;
+    private _secret;
+    /** Lazily initialize client on first use to avoid requiring env vars at import */
+    private get client();
+    private get secret();
+    /**
+     * Create a Nango connect session restricted to specific integrations.
+     */
+    createConnectSession(allowedIntegrations: string[], endUser: {
+        id: string;
+        email?: string;
+    }): Promise<{
+        token: string;
+        connect_link: string;
+        expires_at: string;
+    }>;
+    /**
+     * Fetch GitHub user profile via Nango proxy.
+     */
+    getGithubUser(connectionId: string): Promise<GithubUserProfile>;
+    /**
+     * Retrieve an installation access token from a GitHub App connection.
+     * Use this ONLY when you need the raw token (e.g., for git clone URLs).
+     * For API calls, use the proxy methods instead.
+     */
+    getGithubAppToken(connectionId: string): Promise<string>;
+    /**
+     * Retrieve the user's OAuth access token from a GitHub App OAuth connection.
+     * This is the user-level token (not the installation token).
+     * Use this for operations that require user context (e.g., gh CLI).
+     *
+     * The user token is stored in connection_config.userCredentials.access_token
+     * by Nango's GitHub App OAuth flow. This is a gho_* or ghu_* token that
+     * works for both git operations and gh CLI commands.
+     */
+    getGithubUserOAuthToken(connectionId: string): Promise<string>;
+    /**
+     * Retrieve the user's OAuth token from a 'github' user connection.
+     * This is for the separate GitHub OAuth login (not the App connection).
+     */
+    getGithubUserToken(connectionId: string): Promise<string>;
+    /**
+     * List repositories available to a GitHub App installation using the Nango Proxy.
+     * The proxy automatically handles token injection and refresh.
+     * @see https://nango.dev/docs/implementation-guides/requests-proxy/implement-requests-proxy
+     */
+    listGithubAppRepos(connectionId: string): Promise<{
+        repositories: Array<{
+            id: number;
+            full_name: string;
+            private: boolean;
+            default_branch: string;
+        }>;
+    }>;
+    /**
+     * Get the GitHub App installation ID from a connection.
+     * The installation ID is stored in connection_config.installation_id
+     */
+    getGithubAppInstallationId(connectionId: string): Promise<number | null>;
+    /**
+     * Create an issue via Nango Proxy.
+     */
+    createGithubIssue(connectionId: string, owner: string, repo: string, data: {
+        title: string;
+        body?: string;
+        labels?: string[];
+    }): Promise<{
+        number: number;
+        html_url: string;
+    }>;
+    /**
+     * Create a pull request via Nango Proxy.
+     */
+    createGithubPullRequest(connectionId: string, owner: string, repo: string, data: {
+        title: string;
+        body?: string;
+        head: string;
+        base: string;
+    }): Promise<{
+        number: number;
+        html_url: string;
+    }>;
+    /**
+     * Add a comment to an issue via Nango Proxy.
+     */
+    addGithubIssueComment(connectionId: string, owner: string, repo: string, issueNumber: number, body: string): Promise<{
+        id: number;
+        html_url: string;
+    }>;
+    /**
+     * Update connection end user metadata (e.g., after creating a user record).
+     */
+    updateEndUser(connectionId: string, providerConfigKey: string, endUser: {
+        id: string;
+        email?: string;
+    }): Promise<void>;
+    /**
+     * Delete a connection from Nango.
+     *
+     * Used to remove temporary session connections for returning users
+     * to prevent duplicate connections in Nango. In the two-connection pattern,
+     * new users get a permanent connection but returning users authenticate
+     * with a temporary one that gets deleted.
+     *
+     * @param connectionId - Nango connection ID to delete
+     * @param providerConfigKey - The integration key (e.g., 'github')
+     */
+    deleteConnection(connectionId: string, providerConfigKey: string): Promise<void>;
+    /**
+     * Get connection metadata including end_user info.
+     * Useful when webhook doesn't include end_user data.
+     */
+    getConnection(connectionId: string, providerConfigKey: string): Promise<{
+        id: number;
+        connection_id: string;
+        provider_config_key: string;
+        end_user?: {
+            id?: string;
+            email?: string;
+        };
+        metadata?: Record<string, unknown>;
+    }>;
+    /**
+     * Check if user has access to a specific GitHub repository.
+     * Uses the user's OAuth connection to query GitHub API.
+     * @param connectionId - User's Nango connection ID (github user OAuth)
+     * @param owner - Repository owner
+     * @param repo - Repository name
+     * @returns Access details or null if no access
+     */
+    checkUserRepoAccess(connectionId: string, owner: string, repo: string): Promise<{
+        hasAccess: boolean;
+        permission?: 'admin' | 'write' | 'read' | 'none';
+        repository?: {
+            id: number;
+            fullName: string;
+            isPrivate: boolean;
+            defaultBranch: string;
+        };
+    }>;
+    /**
+     * List all repositories the user has access to via their OAuth connection.
+     * Uses the user's personal OAuth token (not the GitHub App).
+     * @param connectionId - User's Nango connection ID (github user OAuth)
+     * @param options - Pagination and filter options
+     * @returns List of accessible repositories
+     */
+    listUserAccessibleRepos(connectionId: string, options?: {
+        page?: number;
+        perPage?: number;
+        type?: 'all' | 'owner' | 'public' | 'private' | 'member';
+        sort?: 'created' | 'updated' | 'pushed' | 'full_name';
+    }): Promise<{
+        repositories: Array<{
+            id: number;
+            fullName: string;
+            isPrivate: boolean;
+            defaultBranch: string;
+            permissions: {
+                admin: boolean;
+                push: boolean;
+                pull: boolean;
+            };
+        }>;
+        hasMore: boolean;
+    }>;
+    /**
+     * List collaborators for a repository via Nango Proxy.
+     * Uses the GitHub App connection to access repository collaborators.
+     * @param connectionId - GitHub App connection ID
+     * @param owner - Repository owner
+     * @param repo - Repository name
+     * @returns List of collaborators with their permissions
+     */
+    listRepoCollaborators(connectionId: string, owner: string, repo: string): Promise<Array<{
+        id: number;
+        login: string;
+        avatarUrl: string;
+        permission: 'admin' | 'write' | 'read' | 'none';
+    }>>;
+    /**
+     * Verify webhook signature sent by Nango.
+     * Uses the new verifyIncomingWebhookRequest method.
+     * @see https://nango.dev/docs/reference/sdks/node#verify-webhook-signature
+     */
+    verifyWebhookSignature(rawBody: string, headers: Record<string, string | string[] | undefined>): boolean;
+}
+export declare const nangoService: NangoService;
+export {};
+//# sourceMappingURL=nango.d.ts.map