agent-relay 1.6.0 → 2.0.4

package/dist/cloud/services/nango.js

@@ -1,382 +0,0 @@
-import { Nango } from '@nangohq/node';
-import crypto from 'node:crypto';
-import { getConfig } from '../config.js';
-export const NANGO_INTEGRATIONS = {
-    GITHUB_USER: 'github',
-    GITHUB_APP: 'github-app-oauth',
-};
-class NangoService {
-    client;
-    secret;
-    constructor() {
-        const config = getConfig();
-        this.secret = config.nango.secretKey;
-        this.client = new Nango({
-            secretKey: config.nango.secretKey,
-            ...(config.nango.host ? { host: config.nango.host } : {}),
-        });
-    }
-    /**
-     * 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;
-    }
-    /**
-     * 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/dist/cloud/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 '../../wrapper/relay-pty-orchestrator.js';
-/**
- * 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

package/dist/config/relay-config.d.ts

@@ -1,23 +0,0 @@
-export declare const DEFAULT_CONNECTION_CONFIG: {
-    readonly maxFrameBytes: number;
-    readonly heartbeatMs: 5000;
-    readonly heartbeatTimeoutMultiplier: 6;
-    readonly maxWriteQueueSize: 2000;
-    readonly writeQueueHighWaterMark: 1500;
-    readonly writeQueueLowWaterMark: 500;
-};
-export declare const DEFAULT_TMUX_WRAPPER_CONFIG: {
-    readonly pollInterval: 200;
-    readonly idleBeforeInjectMs: 1500;
-    readonly injectRetryMs: 500;
-    readonly debug: false;
-    readonly debugLogIntervalMs: 0;
-    readonly mouseMode: true;
-    readonly activityIdleThresholdMs: 30000;
-    readonly outputStabilityTimeoutMs: 2000;
-    readonly outputStabilityPollMs: 200;
-    readonly streamLogs: true;
-};
-export declare const DEFAULT_IDLE_BEFORE_INJECT_MS = 1500;
-export declare const DEFAULT_IDLE_CONFIDENCE_THRESHOLD = 0.7;
-//# sourceMappingURL=relay-config.d.ts.map

package/dist/config/relay-config.js

@@ -1,23 +0,0 @@
-export const DEFAULT_CONNECTION_CONFIG = {
-    maxFrameBytes: 1024 * 1024,
-    heartbeatMs: 5000,
-    heartbeatTimeoutMultiplier: 6,
-    maxWriteQueueSize: 2000,
-    writeQueueHighWaterMark: 1500,
-    writeQueueLowWaterMark: 500,
-};
-export const DEFAULT_TMUX_WRAPPER_CONFIG = {
-    pollInterval: 200,
-    idleBeforeInjectMs: 1500,
-    injectRetryMs: 500,
-    debug: false,
-    debugLogIntervalMs: 0,
-    mouseMode: true,
-    activityIdleThresholdMs: 30_000,
-    outputStabilityTimeoutMs: 2000,
-    outputStabilityPollMs: 200,
-    streamLogs: true,
-};
-export const DEFAULT_IDLE_BEFORE_INJECT_MS = 1500;
-export const DEFAULT_IDLE_CONFIDENCE_THRESHOLD = 0.7;
-//# sourceMappingURL=relay-config.js.map

package/dist/continuity/index.d.ts

@@ -1,45 +0,0 @@
-/**
- * Continuity System
- *
- * CLI-agnostic session continuity for Agent Relay.
- * Preserves agent state across sessions via ledgers and handoffs.
- *
- * Key components:
- * - Ledgers: Within-session state snapshots (JSON)
- * - Handoffs: Cross-session transfer documents (Markdown)
- * - Parser: Detects `->continuity:` patterns in agent output
- * - Formatter: Formats context for injection
- * - Manager: Central service coordinating all operations
- *
- * Usage:
- * ```typescript
- * import { getContinuityManager, parseContinuityCommand } from './continuity';
- *
- * const manager = getContinuityManager();
- *
- * // On agent spawn - inject previous context
- * const context = await manager.getStartupContext('Alice');
- * if (context) {
- *   await injectMessage(context.formatted);
- * }
- *
- * // On agent output - check for continuity commands
- * const command = parseContinuityCommand(output);
- * if (command) {
- *   const response = await manager.handleCommand('Alice', command);
- *   if (response) {
- *     await injectMessage(response);
- *   }
- * }
- *
- * // On agent exit - auto-save
- * await manager.autoSave('Alice', 'restart');
- * ```
- */
-export type { Decision, FileRef, Ledger, Handoff, HandoffTrigger, ContinuityCommand, StartupContext, ContinuityPaths, SaveLedgerOptions, SearchOptions, } from './types.js';
-export { parseContinuityCommand, hasContinuityCommand, parseSaveContent, parseHandoffContent, extractAllCommands, isPlaceholderValue, filterPlaceholders, type ParsedHandoffContent, } from './parser.js';
-export { formatStartupContext, formatLedger, formatHandoff, formatSearchResults, formatBriefStatus, formatFileRefs, formatDecisions, type FormatOptions, } from './formatter.js';
-export { LedgerStore } from './ledger-store.js';
-export { HandoffStore } from './handoff-store.js';
-export { ContinuityManager, getContinuityManager, resetContinuityManager, type ContinuityManagerOptions, } from './manager.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/continuity/index.js

@@ -1,48 +0,0 @@
-/**
- * Continuity System
- *
- * CLI-agnostic session continuity for Agent Relay.
- * Preserves agent state across sessions via ledgers and handoffs.
- *
- * Key components:
- * - Ledgers: Within-session state snapshots (JSON)
- * - Handoffs: Cross-session transfer documents (Markdown)
- * - Parser: Detects `->continuity:` patterns in agent output
- * - Formatter: Formats context for injection
- * - Manager: Central service coordinating all operations
- *
- * Usage:
- * ```typescript
- * import { getContinuityManager, parseContinuityCommand } from './continuity';
- *
- * const manager = getContinuityManager();
- *
- * // On agent spawn - inject previous context
- * const context = await manager.getStartupContext('Alice');
- * if (context) {
- *   await injectMessage(context.formatted);
- * }
- *
- * // On agent output - check for continuity commands
- * const command = parseContinuityCommand(output);
- * if (command) {
- *   const response = await manager.handleCommand('Alice', command);
- *   if (response) {
- *     await injectMessage(response);
- *   }
- * }
- *
- * // On agent exit - auto-save
- * await manager.autoSave('Alice', 'restart');
- * ```
- */
-// Parser
-export { parseContinuityCommand, hasContinuityCommand, parseSaveContent, parseHandoffContent, extractAllCommands, isPlaceholderValue, filterPlaceholders, } from './parser.js';
-// Formatter
-export { formatStartupContext, formatLedger, formatHandoff, formatSearchResults, formatBriefStatus, formatFileRefs, formatDecisions, } from './formatter.js';
-// Stores
-export { LedgerStore } from './ledger-store.js';
-export { HandoffStore } from './handoff-store.js';
-// Manager
-export { ContinuityManager, getContinuityManager, resetContinuityManager, } from './manager.js';
-//# sourceMappingURL=index.js.map