agent-relay 2.0.23 → 2.0.24

package/packages/cloud/dist/webhooks/responders/linear.js

@@ -1,149 +0,0 @@
-/**
- * Linear Responder
- *
- * Sends responses back to Linear via their GraphQL API.
- * https://developers.linear.app/docs/graphql/working-with-the-graphql-api
- */
-/**
- * Execute a Linear GraphQL mutation
- */
-async function linearGraphQL(apiKey, query, variables) {
-    const response = await fetch('https://api.linear.app/graphql', {
-        method: 'POST',
-        headers: {
-            'Content-Type': 'application/json',
-            'Authorization': apiKey,
-        },
-        body: JSON.stringify({ query, variables }),
-    });
-    return response.json();
-}
-export const linearResponder = {
-    id: 'linear',
-    async respond(event, response, config) {
-        const apiKey = config?.apiKey || process.env.LINEAR_API_KEY;
-        if (!apiKey) {
-            return {
-                success: false,
-                error: 'Linear API key not configured',
-            };
-        }
-        try {
-            switch (response.type) {
-                case 'comment': {
-                    // Create a comment on an issue
-                    const issueId = String(response.target);
-                    const mutation = `
-            mutation CreateComment($issueId: String!, $body: String!) {
-              commentCreate(input: { issueId: $issueId, body: $body }) {
-                success
-                comment {
-                  id
-                  url
-                }
-              }
-            }
-          `;
-                    const result = await linearGraphQL(apiKey, mutation, {
-                        issueId,
-                        body: response.body,
-                    });
-                    if (result.errors?.length) {
-                        return {
-                            success: false,
-                            error: result.errors.map(e => e.message).join(', '),
-                        };
-                    }
-                    const commentCreate = result.data?.commentCreate;
-                    const comment = commentCreate?.comment;
-                    return {
-                        success: !!commentCreate?.success,
-                        id: comment?.id,
-                        url: comment?.url,
-                    };
-                }
-                case 'reaction': {
-                    // Add a reaction/emoji to a comment
-                    const commentId = String(response.target);
-                    const emoji = response.metadata?.emoji || '👍';
-                    const mutation = `
-            mutation CreateReaction($commentId: String!, $emoji: String!) {
-              reactionCreate(input: { commentId: $commentId, emoji: $emoji }) {
-                success
-                reaction {
-                  id
-                }
-              }
-            }
-          `;
-                    const result = await linearGraphQL(apiKey, mutation, {
-                        commentId,
-                        emoji,
-                    });
-                    if (result.errors?.length) {
-                        return {
-                            success: false,
-                            error: result.errors.map(e => e.message).join(', '),
-                        };
-                    }
-                    const reactionCreate = result.data?.reactionCreate;
-                    return {
-                        success: !!reactionCreate?.success,
-                        id: reactionCreate?.reaction?.id,
-                    };
-                }
-                case 'status': {
-                    // Update issue state
-                    const issueId = String(response.target);
-                    const stateId = response.metadata?.stateId;
-                    if (!stateId) {
-                        return {
-                            success: false,
-                            error: 'State ID required for status update',
-                        };
-                    }
-                    const mutation = `
-            mutation UpdateIssue($issueId: String!, $stateId: String!) {
-              issueUpdate(id: $issueId, input: { stateId: $stateId }) {
-                success
-                issue {
-                  id
-                  url
-                }
-              }
-            }
-          `;
-                    const result = await linearGraphQL(apiKey, mutation, {
-                        issueId,
-                        stateId,
-                    });
-                    if (result.errors?.length) {
-                        return {
-                            success: false,
-                            error: result.errors.map(e => e.message).join(', '),
-                        };
-                    }
-                    const issueUpdate = result.data?.issueUpdate;
-                    const issue = issueUpdate?.issue;
-                    return {
-                        success: !!issueUpdate?.success,
-                        id: issue?.id,
-                        url: issue?.url,
-                    };
-                }
-                default:
-                    return {
-                        success: false,
-                        error: `Unknown response type: ${response.type}`,
-                    };
-            }
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : 'Unknown error',
-            };
-        }
-    },
-};
-//# sourceMappingURL=linear.js.map

package/packages/cloud/dist/webhooks/responders/slack.d.ts

@@ -1,20 +0,0 @@
-/**
- * Slack Responder
- *
- * Sends responses back to Slack via their Web API.
- * https://api.slack.com/methods
- */
-import type { WebhookResponder } from '../types.js';
-export declare const slackResponder: WebhookResponder;
-/**
- * Helper to format a message with blocks for richer formatting
- */
-export declare function formatSlackBlocks(text: string, options?: {
-    header?: string;
-    context?: string;
-    actions?: Array<{
-        text: string;
-        url: string;
-    }>;
-}): Array<Record<string, unknown>>;
-//# sourceMappingURL=slack.d.ts.map

package/packages/cloud/dist/webhooks/responders/slack.js

@@ -1,178 +0,0 @@
-/**
- * Slack Responder
- *
- * Sends responses back to Slack via their Web API.
- * https://api.slack.com/methods
- */
-/**
- * Call a Slack Web API method
- */
-async function slackAPI(token, method, body) {
-    const response = await fetch(`https://slack.com/api/${method}`, {
-        method: 'POST',
-        headers: {
-            'Content-Type': 'application/json; charset=utf-8',
-            'Authorization': `Bearer ${token}`,
-        },
-        body: JSON.stringify(body),
-    });
-    return response.json();
-}
-export const slackResponder = {
-    id: 'slack',
-    async respond(event, response, config) {
-        const botToken = config?.botToken || process.env.SLACK_BOT_TOKEN;
-        if (!botToken) {
-            return {
-                success: false,
-                error: 'Slack bot token not configured',
-            };
-        }
-        try {
-            // Get channel from event metadata or response target
-            const channelId = response.metadata?.channel
-                || event.metadata?.channelId
-                || String(response.target);
-            if (!channelId) {
-                return {
-                    success: false,
-                    error: 'Channel ID required',
-                };
-            }
-            switch (response.type) {
-                case 'message': {
-                    // Post a message to a channel
-                    const threadTs = response.metadata?.threadTs
-                        || event.metadata?.threadTs
-                        || event.metadata?.ts;
-                    const result = await slackAPI(botToken, 'chat.postMessage', {
-                        channel: channelId,
-                        text: response.body,
-                        thread_ts: threadTs, // Reply in thread if available
-                        unfurl_links: false,
-                        unfurl_media: false,
-                    });
-                    if (!result.ok) {
-                        return {
-                            success: false,
-                            error: result.error || 'Failed to post message',
-                        };
-                    }
-                    return {
-                        success: true,
-                        id: result.ts,
-                        // Construct Slack message URL
-                        url: `https://slack.com/archives/${channelId}/p${result.ts?.replace('.', '')}`,
-                    };
-                }
-                case 'comment': {
-                    // Same as message, but explicitly in a thread
-                    const threadTs = String(response.target);
-                    const result = await slackAPI(botToken, 'chat.postMessage', {
-                        channel: channelId,
-                        text: response.body,
-                        thread_ts: threadTs,
-                        reply_broadcast: response.metadata?.broadcast === true,
-                    });
-                    if (!result.ok) {
-                        return {
-                            success: false,
-                            error: result.error || 'Failed to post reply',
-                        };
-                    }
-                    return {
-                        success: true,
-                        id: result.ts,
-                    };
-                }
-                case 'reaction': {
-                    // Add a reaction to a message
-                    const ts = String(response.target);
-                    const emoji = response.metadata?.emoji || response.body.replace(/:/g, '');
-                    const result = await slackAPI(botToken, 'reactions.add', {
-                        channel: channelId,
-                        timestamp: ts,
-                        name: emoji,
-                    });
-                    if (!result.ok && result.error !== 'already_reacted') {
-                        return {
-                            success: false,
-                            error: result.error || 'Failed to add reaction',
-                        };
-                    }
-                    return {
-                        success: true,
-                    };
-                }
-                case 'status': {
-                    // Update bot status/presence (not commonly used)
-                    return {
-                        success: false,
-                        error: 'Status updates not implemented for Slack',
-                    };
-                }
-                default:
-                    return {
-                        success: false,
-                        error: `Unknown response type: ${response.type}`,
-                    };
-            }
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : 'Unknown error',
-            };
-        }
-    },
-};
-/**
- * Helper to format a message with blocks for richer formatting
- */
-export function formatSlackBlocks(text, options) {
-    const blocks = [];
-    if (options?.header) {
-        blocks.push({
-            type: 'header',
-            text: {
-                type: 'plain_text',
-                text: options.header,
-                emoji: true,
-            },
-        });
-    }
-    blocks.push({
-        type: 'section',
-        text: {
-            type: 'mrkdwn',
-            text,
-        },
-    });
-    if (options?.context) {
-        blocks.push({
-            type: 'context',
-            elements: [
-                {
-                    type: 'mrkdwn',
-                    text: options.context,
-                },
-            ],
-        });
-    }
-    if (options?.actions?.length) {
-        blocks.push({
-            type: 'actions',
-            elements: options.actions.map(action => ({
-                type: 'button',
-                text: {
-                    type: 'plain_text',
-                    text: action.text,
-                    emoji: true,
-                },
-                url: action.url,
-            })),
-        });
-    }
-    return blocks;
-}
-//# sourceMappingURL=slack.js.map

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

@@ -1,25 +0,0 @@
-/**
- * Generic Webhook Router
- *
- * Routes incoming webhooks from any source through the configurable pipeline:
- * 1. Verify signature
- * 2. Parse payload into normalized events
- * 3. Match events against rules
- * 4. Execute actions
- * 5. Send responses
- */
-import type { WebhookConfig, WebhookSourceConfig, WebhookResult } from './types.js';
-/**
- * Default webhook source configurations
- */
-export declare const defaultSources: Record<string, WebhookSourceConfig>;
-/**
- * Get webhook configuration
- * In the future, this could load from database per-workspace
- */
-export declare function getWebhookConfig(): WebhookConfig;
-/**
- * Process a webhook from any source
- */
-export declare function processWebhook(source: string, payload: string, headers: Record<string, string | string[] | undefined>, config?: WebhookConfig): Promise<WebhookResult>;
-//# sourceMappingURL=router.d.ts.map