agent-relay 2.0.22 → 2.0.24

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

@@ -1,424 +0,0 @@
-import { Nango } from '@nangohq/node';
-import crypto from 'node:crypto';
-import { getConfig } from '../config.js';
-/**
- * Nango Integration Configuration
- *
- * REQUIRED SCOPES:
- * - github (GITHUB_USER): Requires 'user:email' scope for email reconciliation.
- *   Configure this in Nango Dashboard: Integrations → GitHub → OAuth Scopes
- */
-export const NANGO_INTEGRATIONS = {
-    GITHUB_USER: 'github',
-    GITHUB_APP: 'github-app-oauth',
-};
-class NangoService {
-    _client = null;
-    _secret = null;
-    /** Lazily initialize client on first use to avoid requiring env vars at import */
-    get client() {
-        if (!this._client) {
-            const config = getConfig();
-            this._secret = config.nango.secretKey;
-            this._client = new Nango({
-                secretKey: config.nango.secretKey,
-                ...(config.nango.host ? { host: config.nango.host } : {}),
-            });
-        }
-        return this._client;
-    }
-    get secret() {
-        if (!this._secret) {
-            this._secret = getConfig().nango.secretKey;
-        }
-        return this._secret;
-    }
-    /**
-     * Create a Nango connect session restricted to specific integrations.
-     */
-    async createConnectSession(allowedIntegrations, endUser) {
-        const { data } = await this.client.createConnectSession({
-            allowed_integrations: allowedIntegrations,
-            end_user: {
-                id: endUser.id,
-                email: endUser.email,
-            },
-        });
-        return data;
-    }
-    /**
-     * Fetch GitHub user profile via Nango proxy.
-     */
-    async getGithubUser(connectionId) {
-        const response = await this.client.get({
-            connectionId,
-            providerConfigKey: NANGO_INTEGRATIONS.GITHUB_USER,
-            endpoint: '/user',
-        });
-        return response.data;
-    }
-    /**
-     * Fetch all email addresses associated with a GitHub user.
-     * Requires 'user:email' scope to be configured in Nango.
-     * @see https://docs.github.com/en/rest/users/emails#list-email-addresses-for-the-authenticated-user
-     */
-    async getGithubUserEmails(connectionId) {
-        try {
-            const response = await this.client.get({
-                connectionId,
-                providerConfigKey: NANGO_INTEGRATIONS.GITHUB_USER,
-                endpoint: '/user/emails',
-            });
-            return response.data || [];
-        }
-        catch (err) {
-            // If scope is not granted, return empty array
-            const error = err;
-            if (error.response?.status === 403 || error.response?.status === 404) {
-                console.warn('[nango] Cannot fetch user emails - user:email scope may not be granted');
-                return [];
-            }
-            console.error('[nango] Error fetching user emails:', err);
-            return [];
-        }
-    }
-    /**
-     * 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.
-     */
-    async getGithubAppToken(connectionId) {
-        try {
-            const token = await this.client.getToken(NANGO_INTEGRATIONS.GITHUB_APP, connectionId, false, true);
-            // Handle different return formats from Nango
-            if (typeof token === 'string') {
-                return token;
-            }
-            // Nango may return an object with access_token
-            if (token && typeof token === 'object') {
-                const tokenObj = token;
-                if (tokenObj.access_token) {
-                    return tokenObj.access_token;
-                }
-                if (tokenObj.token) {
-                    return tokenObj.token;
-                }
-            }
-            console.error('[nango] Unexpected token format:', typeof token, token);
-            throw new Error('Expected GitHub App token to be a string');
-        }
-        catch (err) {
-            // Handle 404 (connection not found) gracefully
-            const error = err;
-            const status = error.response?.status || error.status;
-            if (status === 404) {
-                throw new Error(`GitHub App connection not found: ${connectionId} (may have been disconnected)`);
-            }
-            // Re-throw with cleaner message
-            throw new Error(`Failed to get GitHub App token: ${err.message || 'Unknown error'}`);
-        }
-    }
-    /**
-     * 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.
-     */
-    async getGithubUserOAuthToken(connectionId) {
-        try {
-            const connection = await this.client.getConnection(NANGO_INTEGRATIONS.GITHUB_APP, connectionId);
-            const connConfig = connection.connection_config;
-            // Check for userCredentials.access_token (the user's personal OAuth token)
-            const userCredentials = connConfig?.userCredentials;
-            if (userCredentials?.access_token && typeof userCredentials.access_token === 'string') {
-                return userCredentials.access_token;
-            }
-            throw new Error('No userCredentials.access_token in connection_config');
-        }
-        catch (err) {
-            const message = err instanceof Error ? err.message : 'Unknown error';
-            console.log('[nango] getGithubUserOAuthToken failed:', message);
-            throw new Error('Could not retrieve GitHub user OAuth token');
-        }
-    }
-    /**
-     * Retrieve the user's OAuth token from a 'github' user connection.
-     * This is for the separate GitHub OAuth login (not the App connection).
-     */
-    async getGithubUserToken(connectionId) {
-        const token = await this.client.getToken(NANGO_INTEGRATIONS.GITHUB_USER, connectionId);
-        if (typeof token === 'string') {
-            return token;
-        }
-        if (token && typeof token === 'object') {
-            const tokenObj = token;
-            if (tokenObj.access_token) {
-                return tokenObj.access_token;
-            }
-            if (tokenObj.token) {
-                return tokenObj.token;
-            }
-        }
-        throw new Error('Could not retrieve GitHub user token');
-    }
-    /**
-     * 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
-     */
-    async listGithubAppRepos(connectionId) {
-        const response = await this.client.get({
-            connectionId,
-            providerConfigKey: NANGO_INTEGRATIONS.GITHUB_APP,
-            endpoint: '/installation/repositories',
-            params: { per_page: '100' },
-        });
-        return response.data;
-    }
-    /**
-     * Get the GitHub App installation ID from a connection.
-     * The installation ID is stored in connection_config.installation_id
-     */
-    async getGithubAppInstallationId(connectionId) {
-        try {
-            const connection = await this.client.getConnection(NANGO_INTEGRATIONS.GITHUB_APP, connectionId);
-            // Extract installation_id from connection_config (where Nango stores it for GitHub App OAuth)
-            const connectionConfig = connection.connection_config;
-            if (connectionConfig?.installation_id) {
-                return Number(connectionConfig.installation_id);
-            }
-            console.warn('[nango] No installation_id in connection_config');
-            return null;
-        }
-        catch (err) {
-            console.error('[nango] Failed to get installation ID:', err);
-            return null;
-        }
-    }
-    /**
-     * Create an issue via Nango Proxy.
-     */
-    async createGithubIssue(connectionId, owner, repo, data) {
-        const response = await this.client.post({
-            connectionId,
-            providerConfigKey: NANGO_INTEGRATIONS.GITHUB_APP,
-            endpoint: `/repos/${owner}/${repo}/issues`,
-            data,
-        });
-        return response.data;
-    }
-    /**
-     * Create a pull request via Nango Proxy.
-     */
-    async createGithubPullRequest(connectionId, owner, repo, data) {
-        const response = await this.client.post({
-            connectionId,
-            providerConfigKey: NANGO_INTEGRATIONS.GITHUB_APP,
-            endpoint: `/repos/${owner}/${repo}/pulls`,
-            data,
-        });
-        return response.data;
-    }
-    /**
-     * Add a comment to an issue via Nango Proxy.
-     */
-    async addGithubIssueComment(connectionId, owner, repo, issueNumber, body) {
-        const response = await this.client.post({
-            connectionId,
-            providerConfigKey: NANGO_INTEGRATIONS.GITHUB_APP,
-            endpoint: `/repos/${owner}/${repo}/issues/${issueNumber}/comments`,
-            data: { body },
-        });
-        return response.data;
-    }
-    /**
-     * Update connection end user metadata (e.g., after creating a user record).
-     */
-    async updateEndUser(connectionId, providerConfigKey, endUser) {
-        await this.client.patchConnection({ connectionId, provider_config_key: providerConfigKey }, { end_user: endUser });
-    }
-    /**
-     * 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')
-     */
-    async deleteConnection(connectionId, providerConfigKey) {
-        await this.client.deleteConnection(providerConfigKey, connectionId);
-    }
-    /**
-     * Get connection metadata including end_user info.
-     * Useful when webhook doesn't include end_user data.
-     */
-    async getConnection(connectionId, providerConfigKey) {
-        const connection = await this.client.getConnection(providerConfigKey, connectionId);
-        return connection;
-    }
-    /**
-     * 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
-     */
-    async checkUserRepoAccess(connectionId, owner, repo) {
-        try {
-            const response = await this.client.get({
-                connectionId,
-                providerConfigKey: NANGO_INTEGRATIONS.GITHUB_USER,
-                endpoint: `/repos/${owner}/${repo}`,
-            });
-            const data = response.data;
-            let permission = 'none';
-            if (data.permissions) {
-                if (data.permissions.admin) {
-                    permission = 'admin';
-                }
-                else if (data.permissions.push) {
-                    permission = 'write';
-                }
-                else if (data.permissions.pull) {
-                    permission = 'read';
-                }
-            }
-            return {
-                hasAccess: true,
-                permission,
-                repository: {
-                    id: data.id,
-                    fullName: data.full_name,
-                    isPrivate: data.private,
-                    defaultBranch: data.default_branch,
-                },
-            };
-        }
-        catch (err) {
-            // 404 = no access or repo doesn't exist
-            const error = err;
-            if (error.response?.status === 404 || error.response?.status === 403) {
-                return { hasAccess: false };
-            }
-            console.error('[nango] checkUserRepoAccess error:', err);
-            throw err;
-        }
-    }
-    /**
-     * 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
-     */
-    async listUserAccessibleRepos(connectionId, options) {
-        const page = options?.page ?? 1;
-        const perPage = options?.perPage ?? 100;
-        const type = options?.type ?? 'all';
-        const sort = options?.sort ?? 'updated';
-        const response = await this.client.get({
-            connectionId,
-            providerConfigKey: NANGO_INTEGRATIONS.GITHUB_USER,
-            endpoint: '/user/repos',
-            params: {
-                page: String(page),
-                per_page: String(perPage),
-                type,
-                sort,
-                direction: 'desc',
-            },
-        });
-        const repos = response.data || [];
-        return {
-            repositories: repos.map(r => ({
-                id: r.id,
-                fullName: r.full_name,
-                isPrivate: r.private,
-                defaultBranch: r.default_branch,
-                permissions: r.permissions || { admin: false, push: false, pull: false },
-            })),
-            hasMore: repos.length === perPage,
-        };
-    }
-    /**
-     * 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
-     */
-    async listRepoCollaborators(connectionId, owner, repo) {
-        try {
-            const response = await this.client.get({
-                connectionId,
-                providerConfigKey: NANGO_INTEGRATIONS.GITHUB_APP,
-                endpoint: `/repos/${owner}/${repo}/collaborators`,
-                params: { per_page: '100' },
-            });
-            return (response.data || []).map(collab => {
-                let permission = 'none';
-                if (collab.permissions) {
-                    if (collab.permissions.admin) {
-                        permission = 'admin';
-                    }
-                    else if (collab.permissions.push) {
-                        permission = 'write';
-                    }
-                    else if (collab.permissions.pull) {
-                        permission = 'read';
-                    }
-                }
-                return {
-                    id: collab.id,
-                    login: collab.login,
-                    avatarUrl: collab.avatar_url,
-                    permission,
-                };
-            });
-        }
-        catch (err) {
-            const error = err;
-            // 403 = no permission to view collaborators, 404 = repo not found
-            if (error.response?.status === 403 || error.response?.status === 404) {
-                console.warn(`[nango] Cannot list collaborators for ${owner}/${repo}: status ${error.response.status}`);
-                return [];
-            }
-            console.error('[nango] listRepoCollaborators error:', err);
-            throw err;
-        }
-    }
-    /**
-     * Verify webhook signature sent by Nango.
-     * Uses the new verifyIncomingWebhookRequest method.
-     * @see https://nango.dev/docs/reference/sdks/node#verify-webhook-signature
-     */
-    verifyWebhookSignature(rawBody, headers) {
-        try {
-            // Use the new method: verifyIncomingWebhookRequest(body, headers)
-            return this.client.verifyIncomingWebhookRequest(rawBody, headers);
-        }
-        catch (err) {
-            console.error('[nango] verifyIncomingWebhookRequest error:', err);
-            // Fall back to manual HMAC verification using the secret key
-            const signature = headers['x-nango-signature'];
-            const hmacSha256 = headers['x-nango-hmac-sha256'];
-            if (!signature && !hmacSha256)
-                return false;
-            const expectedSignature = crypto
-                .createHmac('sha256', this.secret)
-                .update(rawBody)
-                .digest('hex');
-            return signature === expectedSignature || hmacSha256 === expectedSignature;
-        }
-    }
-}
-export const nangoService = new NangoService();
-//# sourceMappingURL=nango.js.map

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

@@ -1,131 +0,0 @@
-/**
- * Cloud Persistence Service
- *
- * Handles durable persistence of agent session data for cloud deployments.
- * Subscribes to wrapper events ('summary', 'session-end') and persists
- * to PostgreSQL via Drizzle ORM.
- *
- * This decouples wrappers from storage concerns - the wrapper emits events,
- * this service handles persistence. Different storage backends can be swapped
- * by implementing alternative persistence services.
- *
- * @see RelayPtyOrchestratorEvents in src/wrapper/relay-pty-orchestrator.ts for event definitions
- */
-import type { RelayPtyOrchestrator } from '@agent-relay/wrapper';
-/**
- * Configuration for CloudPersistenceService
- */
-export interface CloudPersistenceConfig {
-    /** Workspace ID for scoping sessions */
-    workspaceId: string;
-    /** Optional callback when summary is persisted */
-    onSummaryPersisted?: (agentName: string, summaryId: string) => void;
-    /** Optional callback when session ends */
-    onSessionEnded?: (agentName: string, sessionId: string) => void;
-}
-/**
- * CloudPersistenceService manages durable storage for agent sessions.
- *
- * Usage:
- * ```typescript
- * const persistence = new CloudPersistenceService({
- *   workspaceId: 'workspace-123',
- * });
- *
- * // Bind to a RelayPtyOrchestrator instance
- * const pty = new RelayPtyOrchestrator(config);
- * const sessionId = await persistence.bindToWrapper(pty);
- *
- * // When done, unbind to clean up listeners
- * persistence.unbindFromWrapper(pty);
- * ```
- */
-export declare class CloudPersistenceService {
-    private config;
-    private boundWrappers;
-    constructor(config: CloudPersistenceConfig);
-    /**
-     * Bind to a RelayPtyOrchestrator instance and start persisting its events.
-     * Creates a new agent session record and returns the session ID.
-     *
-     * @param wrapper The RelayPtyOrchestrator to bind to
-     * @returns The session ID for this agent session
-     */
-    bindToRelayPtyOrchestrator(wrapper: RelayPtyOrchestrator): Promise<string>;
-    /**
-     * Unbind from a RelayPtyOrchestrator and clean up event listeners.
-     *
-     * @param wrapper The RelayPtyOrchestrator to unbind from
-     */
-    unbindFromRelayPtyOrchestrator(wrapper: RelayPtyOrchestrator): void;
-    /**
-     * Handle a summary event - persist to agent_summaries table.
-     */
-    private handleSummary;
-    /**
-     * Handle a session-end event - update agent_sessions with end marker.
-     */
-    private handleSessionEnd;
-    /**
-     * Get the session ID for a bound wrapper.
-     */
-    getSessionId(wrapper: RelayPtyOrchestrator): string | undefined;
-    /**
-     * Get all summaries for a session.
-     */
-    getSessionSummaries(sessionId: string): Promise<{
-        id: string;
-        sessionId: string;
-        agentName: string;
-        summary: {
-            currentTask?: string;
-            completedTasks?: string[];
-            decisions?: string[];
-            context?: string;
-            files?: string[];
-        };
-        createdAt: Date;
-    }[]>;
-    /**
-     * Get the latest summary for an agent in THIS workspace.
-     * Joins through agent_sessions to ensure workspace scoping.
-     */
-    getLatestSummary(agentName: string): Promise<{
-        id: string;
-        sessionId: string;
-        agentName: string;
-        summary: {
-            currentTask?: string;
-            completedTasks?: string[];
-            decisions?: string[];
-            context?: string;
-            files?: string[];
-        };
-        createdAt: Date;
-    }>;
-    /**
-     * Get active sessions for a workspace.
-     */
-    getActiveSessions(): Promise<{
-        id: string;
-        workspaceId: string;
-        agentName: string;
-        status: string;
-        startedAt: Date;
-        endedAt: Date | null;
-        endMarker: {
-            summary?: string;
-            completedTasks?: string[];
-        } | null;
-        metadata: unknown;
-    }[]>;
-    /**
-     * Clean up all bindings.
-     */
-    destroy(): void;
-}
-/**
- * Factory function to create a persistence service for a workspace.
- */
-export declare function createPersistenceService(workspaceId: string): CloudPersistenceService;
-//# sourceMappingURL=persistence.d.ts.map