agent-relay 2.0.22 → 2.0.24

package/packages/cloud/dist/services/workspace-keepalive.js

@@ -1,234 +0,0 @@
-/**
- * Workspace Keepalive Service
- *
- * Prevents Fly.io from idling workspace machines that have active agents running.
- *
- * Problem: Fly.io uses request-based concurrency tracking to determine when to
- * idle a machine. If a Claude agent is running but no HTTP requests are coming
- * in (e.g., no one has the dashboard open), Fly.io may idle the machine.
- *
- * Solution: The cloud server periodically pings workspace machines that have
- * active agents. This inbound HTTP request counts as activity for Fly.io's
- * idle detection, keeping the machine awake.
- *
- * Flow:
- * 1. Daemons report their running agents via heartbeat
- * 2. This service queries for workspaces with active agents
- * 3. Pings each workspace's /keep-alive endpoint
- * 4. Workspace stays awake as long as agents are active
- */
-import { EventEmitter } from 'events';
-import { db } from '../db/index.js';
-const DEFAULT_CONFIG = {
-    pingIntervalMs: 60_000, // 1 minute (well under Fly's ~5-10 min idle timeout)
-    requestTimeoutMs: 5_000, // 5 seconds
-    staleThresholdMs: 2 * 60 * 1000, // 2 minutes
-    verbose: false,
-};
-export class WorkspaceKeepaliveService extends EventEmitter {
-    config;
-    pingTimer = null;
-    stats = {
-        lastRun: null,
-        totalPings: 0,
-        successfulPings: 0,
-        failedPings: 0,
-        activeWorkspaces: 0,
-    };
-    constructor(config = {}) {
-        super();
-        this.config = { ...DEFAULT_CONFIG, ...config };
-    }
-    /**
-     * Start the keepalive service
-     */
-    start() {
-        if (this.pingTimer) {
-            return; // Already running
-        }
-        console.log('[keepalive] Starting workspace keepalive service', {
-            intervalMs: this.config.pingIntervalMs,
-        });
-        // Initial ping
-        this.pingActiveWorkspaces().catch((err) => {
-            console.error('[keepalive] Initial ping failed:', err);
-        });
-        // Start periodic pings
-        this.pingTimer = setInterval(() => {
-            this.pingActiveWorkspaces().catch((err) => {
-                console.error('[keepalive] Periodic ping failed:', err);
-            });
-        }, this.config.pingIntervalMs);
-    }
-    /**
-     * Stop the keepalive service
-     */
-    stop() {
-        if (this.pingTimer) {
-            clearInterval(this.pingTimer);
-            this.pingTimer = null;
-            console.log('[keepalive] Stopped workspace keepalive service');
-        }
-    }
-    /**
-     * Get current statistics
-     */
-    getStats() {
-        return { ...this.stats };
-    }
-    /**
-     * Find workspaces with active agents and ping them
-     */
-    async pingActiveWorkspaces() {
-        const startTime = Date.now();
-        try {
-            // Find workspaces with active agents
-            const activeWorkspaces = await this.findWorkspacesWithActiveAgents();
-            this.stats.activeWorkspaces = activeWorkspaces.length;
-            this.stats.lastRun = new Date();
-            if (activeWorkspaces.length === 0) {
-                if (this.config.verbose) {
-                    console.log('[keepalive] No active workspaces to ping');
-                }
-                return;
-            }
-            if (this.config.verbose) {
-                console.log(`[keepalive] Pinging ${activeWorkspaces.length} active workspace(s)`);
-            }
-            // Ping each workspace in parallel
-            const results = await Promise.allSettled(activeWorkspaces.map((ws) => this.pingWorkspace(ws)));
-            // Update stats
-            for (const result of results) {
-                this.stats.totalPings++;
-                if (result.status === 'fulfilled' && result.value) {
-                    this.stats.successfulPings++;
-                }
-                else {
-                    this.stats.failedPings++;
-                }
-            }
-            const duration = Date.now() - startTime;
-            if (this.config.verbose) {
-                console.log(`[keepalive] Ping cycle complete`, {
-                    workspaces: activeWorkspaces.length,
-                    durationMs: duration,
-                });
-            }
-            this.emit('ping-cycle', {
-                workspaces: activeWorkspaces.length,
-                duration,
-                results: results.map((r) => r.status === 'fulfilled' && r.value),
-            });
-        }
-        catch (err) {
-            console.error('[keepalive] Error in ping cycle:', err);
-            this.emit('error', err);
-        }
-    }
-    /**
-     * Find all workspaces that have daemons with active agents
-     */
-    async findWorkspacesWithActiveAgents() {
-        const staleThreshold = new Date(Date.now() - this.config.staleThresholdMs);
-        // Get all workspaces and check each for active agents
-        const allWorkspaces = await db.workspaces.findAll();
-        const activeWorkspaces = [];
-        for (const workspace of allWorkspaces) {
-            // Skip workspaces that aren't running or don't have a URL
-            if (workspace.status !== 'running' || !workspace.publicUrl) {
-                continue;
-            }
-            // Get daemons for this workspace
-            const daemons = await db.linkedDaemons.findByWorkspaceId(workspace.id);
-            for (const daemon of daemons) {
-                // Skip offline daemons or those with stale heartbeats
-                if (daemon.status !== 'online')
-                    continue;
-                if (daemon.lastSeenAt && daemon.lastSeenAt < staleThreshold)
-                    continue;
-                // Check if daemon has any active agents
-                const metadata = daemon.metadata;
-                const agents = metadata?.agents || [];
-                // Count agents that appear to be active (not offline/disconnected)
-                const activeAgents = agents.filter((a) => a.status === 'online' || a.status === 'running' || a.status === 'active');
-                if (activeAgents.length > 0) {
-                    activeWorkspaces.push({
-                        workspaceId: workspace.id,
-                        publicUrl: workspace.publicUrl,
-                        daemonId: daemon.id,
-                        daemonName: daemon.name,
-                        agentCount: activeAgents.length,
-                    });
-                    // Only need one daemon per workspace to keep it alive
-                    break;
-                }
-            }
-        }
-        return activeWorkspaces;
-    }
-    /**
-     * Ping a single workspace's keep-alive endpoint
-     */
-    async pingWorkspace(workspace) {
-        const url = `${workspace.publicUrl.replace(/\/$/, '')}/keep-alive`;
-        try {
-            const controller = new AbortController();
-            const timeout = setTimeout(() => controller.abort(), this.config.requestTimeoutMs);
-            const response = await fetch(url, {
-                method: 'GET',
-                signal: controller.signal,
-                headers: {
-                    'User-Agent': 'AgentRelay-Keepalive/1.0',
-                },
-            });
-            clearTimeout(timeout);
-            if (response.ok) {
-                const data = await response.json();
-                if (this.config.verbose) {
-                    console.log(`[keepalive] Pinged ${workspace.daemonName}`, {
-                        workspaceId: workspace.workspaceId,
-                        activeAgents: data.activeAgents,
-                    });
-                }
-                return true;
-            }
-            else {
-                console.warn(`[keepalive] Ping failed for ${workspace.daemonName}:`, {
-                    status: response.status,
-                    url,
-                });
-                return false;
-            }
-        }
-        catch (err) {
-            // Don't log aborted requests as errors (timeout is expected for stopped machines)
-            if (err instanceof Error && err.name === 'AbortError') {
-                if (this.config.verbose) {
-                    console.log(`[keepalive] Ping timeout for ${workspace.daemonName} (machine may be starting)`);
-                }
-            }
-            else {
-                console.warn(`[keepalive] Ping error for ${workspace.daemonName}:`, err);
-            }
-            return false;
-        }
-    }
-}
-// Singleton instance
-let _keepaliveService = null;
-/**
- * Get or create the keepalive service singleton
- */
-export function getWorkspaceKeepaliveService(config) {
-    if (!_keepaliveService) {
-        _keepaliveService = new WorkspaceKeepaliveService(config);
-    }
-    return _keepaliveService;
-}
-/**
- * Create a new keepalive service (for testing)
- */
-export function createWorkspaceKeepaliveService(config) {
-    return new WorkspaceKeepaliveService(config);
-}
-//# sourceMappingURL=workspace-keepalive.js.map

package/packages/cloud/dist/shims/consensus.d.ts

@@ -1,23 +0,0 @@
-export interface Vote {
-    agent: string;
-    vote: string;
-    comment?: string;
-    timestamp?: number;
-}
-export interface Proposal {
-    id: string;
-    title: string;
-    description?: string;
-    status: string;
-    proposer?: string;
-    participants: string[];
-    votes: Vote[];
-    createdAt: number;
-    updatedAt?: number;
-}
-export interface ConsensusState {
-    proposals: Proposal[];
-    stats?: Record<string, unknown>;
-}
-export declare function getConsensus(_workspaceId?: string): Promise<ConsensusState>;
-//# sourceMappingURL=consensus.d.ts.map

package/packages/cloud/dist/shims/consensus.js

@@ -1,5 +0,0 @@
-// Stubbed implementation for build-time; real implementation lives in daemon (Phase 6)
-export async function getConsensus(_workspaceId) {
-    return { proposals: [] };
-}
-//# sourceMappingURL=consensus.js.map

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

@@ -1,24 +0,0 @@
-/**
- * Generic Webhook System
- *
- * A configurable webhook system that can handle events from any source
- * (GitHub, GitLab, Linear, Slack, Jira, etc.) and route them to agents.
- *
- * Components:
- * - Parsers: Transform source-specific payloads to normalized events
- * - Responders: Send responses back to source systems
- * - Rules Engine: Match events to actions based on configuration
- * - Router: Orchestrates the full webhook processing pipeline
- */
-export * from './types.js';
-export { getParser, registerParser, parsers } from './parsers/index.js';
-export { githubParser } from './parsers/github.js';
-export { linearParser } from './parsers/linear.js';
-export { slackParser } from './parsers/slack.js';
-export { getResponder, registerResponder, responders } from './responders/index.js';
-export { githubResponder } from './responders/github.js';
-export { linearResponder } from './responders/linear.js';
-export { slackResponder, formatSlackBlocks } from './responders/slack.js';
-export { matchesRule, findMatchingRules, resolveActionTemplate, defaultRules, } from './rules-engine.js';
-export { processWebhook, getWebhookConfig, defaultSources, } from './router.js';
-//# sourceMappingURL=index.d.ts.map

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

@@ -1,29 +0,0 @@
-/**
- * Generic Webhook System
- *
- * A configurable webhook system that can handle events from any source
- * (GitHub, GitLab, Linear, Slack, Jira, etc.) and route them to agents.
- *
- * Components:
- * - Parsers: Transform source-specific payloads to normalized events
- * - Responders: Send responses back to source systems
- * - Rules Engine: Match events to actions based on configuration
- * - Router: Orchestrates the full webhook processing pipeline
- */
-// Types
-export * from './types.js';
-// Parsers
-export { getParser, registerParser, parsers } from './parsers/index.js';
-export { githubParser } from './parsers/github.js';
-export { linearParser } from './parsers/linear.js';
-export { slackParser } from './parsers/slack.js';
-// Responders
-export { getResponder, registerResponder, responders } from './responders/index.js';
-export { githubResponder } from './responders/github.js';
-export { linearResponder } from './responders/linear.js';
-export { slackResponder, formatSlackBlocks } from './responders/slack.js';
-// Rules Engine
-export { matchesRule, findMatchingRules, resolveActionTemplate, defaultRules, } from './rules-engine.js';
-// Router
-export { processWebhook, getWebhookConfig, defaultSources, } from './router.js';
-//# sourceMappingURL=index.js.map

package/packages/cloud/dist/webhooks/parsers/github.d.ts

@@ -1,8 +0,0 @@
-/**
- * GitHub Webhook Parser
- *
- * Transforms GitHub webhook payloads into normalized events.
- */
-import type { WebhookParser } from '../types.js';
-export declare const githubParser: WebhookParser;
-//# sourceMappingURL=github.d.ts.map

package/packages/cloud/dist/webhooks/parsers/github.js

@@ -1,234 +0,0 @@
-/**
- * GitHub Webhook Parser
- *
- * Transforms GitHub webhook payloads into normalized events.
- */
-/**
- * Extract @mentions from text
- */
-function extractMentions(text) {
-    if (!text)
-        return [];
-    const mentionPattern = /@([a-zA-Z][a-zA-Z0-9_-]*)/g;
-    const mentions = [];
-    let match;
-    while ((match = mentionPattern.exec(text)) !== null) {
-        mentions.push(match[1].toLowerCase());
-    }
-    return [...new Set(mentions)];
-}
-/**
- * Map GitHub priority labels to normalized priority
- */
-function extractPriority(labels) {
-    const labelNames = labels.map(l => l.name.toLowerCase());
-    if (labelNames.includes('critical') || labelNames.includes('p0'))
-        return 'critical';
-    if (labelNames.includes('high') || labelNames.includes('p1'))
-        return 'high';
-    if (labelNames.includes('medium') || labelNames.includes('p2'))
-        return 'medium';
-    if (labelNames.includes('low') || labelNames.includes('p3'))
-        return 'low';
-    return undefined;
-}
-export const githubParser = {
-    id: 'github',
-    parse(payload, headers) {
-        const eventType = headers['x-github-event'];
-        const deliveryId = headers['x-github-delivery'];
-        const data = payload;
-        const events = [];
-        const repository = data.repository;
-        const sender = data.sender;
-        const baseEvent = {
-            id: deliveryId || `github-${Date.now()}`,
-            source: 'github',
-            timestamp: new Date(),
-            actor: {
-                id: String(sender?.id || 'unknown'),
-                name: String(sender?.login || 'unknown'),
-            },
-            context: {
-                name: String(repository?.full_name || 'unknown'),
-                url: String(repository?.html_url || ''),
-            },
-            labels: [],
-            mentions: [],
-            metadata: {},
-            rawPayload: payload,
-        };
-        switch (eventType) {
-            case 'check_run': {
-                const checkRun = data.check_run;
-                const action = data.action;
-                const conclusion = checkRun?.conclusion;
-                const pullRequests = checkRun?.pull_requests;
-                if (action === 'completed' && conclusion === 'failure' && pullRequests?.length) {
-                    const pr = pullRequests[0];
-                    const output = checkRun.output;
-                    const annotations = output?.annotations;
-                    events.push({
-                        ...baseEvent,
-                        type: 'ci_failure',
-                        item: {
-                            type: 'check',
-                            id: String(checkRun.id),
-                            number: pr.number,
-                            title: String(checkRun.name),
-                            body: String(output?.summary || ''),
-                            url: String(checkRun.html_url || ''),
-                            state: 'failure',
-                        },
-                        metadata: {
-                            checkName: checkRun.name,
-                            conclusion,
-                            branch: pr.head?.ref,
-                            commitSha: pr.head?.sha,
-                            failureTitle: output?.title,
-                            failureSummary: output?.summary,
-                            failureDetails: output?.text,
-                            annotations: annotations?.map(a => ({
-                                path: a.path,
-                                startLine: a.start_line,
-                                endLine: a.end_line,
-                                level: a.annotation_level,
-                                message: a.message,
-                            })),
-                        },
-                    });
-                }
-                break;
-            }
-            case 'issues': {
-                const issue = data.issue;
-                const action = data.action;
-                const labels = (issue?.labels || []);
-                if (action === 'opened' || action === 'labeled') {
-                    events.push({
-                        ...baseEvent,
-                        type: 'issue_created',
-                        item: {
-                            type: 'issue',
-                            id: String(issue.id),
-                            number: issue.number,
-                            title: String(issue.title),
-                            body: String(issue.body || ''),
-                            url: String(issue.html_url),
-                            state: String(issue.state),
-                        },
-                        labels: labels.map(l => l.name),
-                        priority: extractPriority(labels),
-                        mentions: extractMentions(issue.body),
-                        metadata: {
-                            action,
-                            assignees: (issue.assignees || []).map(a => a.login),
-                        },
-                    });
-                }
-                break;
-            }
-            case 'issue_comment': {
-                const issue = data.issue;
-                const comment = data.comment;
-                const action = data.action;
-                const isPR = !!(issue?.pull_request);
-                if (action === 'created') {
-                    const mentions = extractMentions(comment.body);
-                    if (mentions.length > 0) {
-                        events.push({
-                            ...baseEvent,
-                            type: 'mention',
-                            item: {
-                                type: isPR ? 'pull_request' : 'issue',
-                                id: String(comment.id),
-                                number: issue.number,
-                                title: String(issue.title),
-                                body: String(comment.body),
-                                url: String(comment.html_url),
-                            },
-                            mentions,
-                            metadata: {
-                                commentId: comment.id,
-                                commentUrl: comment.html_url,
-                                isPR,
-                            },
-                        });
-                    }
-                }
-                break;
-            }
-            case 'pull_request_review_comment': {
-                const pr = data.pull_request;
-                const comment = data.comment;
-                const action = data.action;
-                if (action === 'created') {
-                    const mentions = extractMentions(comment.body);
-                    if (mentions.length > 0) {
-                        events.push({
-                            ...baseEvent,
-                            type: 'mention',
-                            item: {
-                                type: 'pull_request',
-                                id: String(comment.id),
-                                number: pr.number,
-                                title: String(pr.title),
-                                body: String(comment.body),
-                                url: String(comment.html_url),
-                            },
-                            mentions,
-                            metadata: {
-                                commentId: comment.id,
-                                commentUrl: comment.html_url,
-                                filePath: comment.path,
-                                line: comment.line,
-                                isPR: true,
-                                isReviewComment: true,
-                            },
-                        });
-                    }
-                }
-                break;
-            }
-            case 'pull_request': {
-                const pr = data.pull_request;
-                const action = data.action;
-                const labels = (pr?.labels || []);
-                if (action === 'opened') {
-                    events.push({
-                        ...baseEvent,
-                        type: 'pr_opened',
-                        item: {
-                            type: 'pull_request',
-                            id: String(pr.id),
-                            number: pr.number,
-                            title: String(pr.title),
-                            body: String(pr.body || ''),
-                            url: String(pr.html_url),
-                            state: String(pr.state),
-                        },
-                        labels: labels.map(l => l.name),
-                        priority: extractPriority(labels),
-                        mentions: extractMentions(pr.body),
-                        metadata: {
-                            action,
-                            head: pr.head?.ref,
-                            base: pr.base?.ref,
-                            draft: pr.draft,
-                        },
-                    });
-                }
-                break;
-            }
-            default:
-                // Unknown event type - create a generic event
-                events.push({
-                    ...baseEvent,
-                    type: `github.${eventType}`,
-                    metadata: { action: data.action },
-                });
-        }
-        return events;
-    },
-};
-//# sourceMappingURL=github.js.map

package/packages/cloud/dist/webhooks/parsers/index.d.ts

@@ -1,23 +0,0 @@
-/**
- * Webhook Parsers Index
- *
- * Registry of all available parsers.
- */
-import type { WebhookParser } from '../types.js';
-import { githubParser } from './github.js';
-import { linearParser } from './linear.js';
-import { slackParser } from './slack.js';
-/**
- * Registry of all available parsers
- */
-export declare const parsers: Record<string, WebhookParser>;
-/**
- * Get a parser by ID
- */
-export declare function getParser(id: string): WebhookParser | undefined;
-/**
- * Register a custom parser
- */
-export declare function registerParser(parser: WebhookParser): void;
-export { githubParser, linearParser, slackParser };
-//# sourceMappingURL=index.d.ts.map

package/packages/cloud/dist/webhooks/parsers/index.js

@@ -1,30 +0,0 @@
-/**
- * Webhook Parsers Index
- *
- * Registry of all available parsers.
- */
-import { githubParser } from './github.js';
-import { linearParser } from './linear.js';
-import { slackParser } from './slack.js';
-/**
- * Registry of all available parsers
- */
-export const parsers = {
-    github: githubParser,
-    linear: linearParser,
-    slack: slackParser,
-};
-/**
- * Get a parser by ID
- */
-export function getParser(id) {
-    return parsers[id];
-}
-/**
- * Register a custom parser
- */
-export function registerParser(parser) {
-    parsers[parser.id] = parser;
-}
-export { githubParser, linearParser, slackParser };
-//# sourceMappingURL=index.js.map

package/packages/cloud/dist/webhooks/parsers/linear.d.ts

@@ -1,9 +0,0 @@
-/**
- * Linear Webhook Parser
- *
- * Transforms Linear webhook payloads into normalized events.
- * Linear webhooks: https://developers.linear.app/docs/graphql/webhooks
- */
-import type { WebhookParser } from '../types.js';
-export declare const linearParser: WebhookParser;
-//# sourceMappingURL=linear.d.ts.map