thaddeus 1.0.26 → 1.0.28

package/src/integrations/providers/GitHubProvider.js

@@ -0,0 +1,217 @@
+/**
+ * GitHub Provider -- GitHub OAuth + REST API
+ * Actions: listRepos, listIssues, createIssue, listPRs, createPR, getFile
+ */
+import { BaseProvider } from './BaseProvider.js';
+export class GitHubProvider extends BaseProvider {
+    constructor() {
+        super('github', 'GitHub', 'oauth2');
+        this.oauthConfig = {
+            authUrl: 'https://github.com/login/oauth/authorize',
+            tokenUrl: 'https://github.com/login/oauth/access_token',
+            clientId: '',
+            clientSecret: '',
+            scopes: ['repo', 'read:org', 'read:user', 'workflow'],
+        };
+    }
+    getConfigFields() {
+        return [
+            { name: 'clientId', label: 'GitHub OAuth App Client ID' },
+            { name: 'clientSecret', label: 'GitHub OAuth App Client Secret', secret: true },
+        ];
+    }
+    async configure(credentials) {
+        if (this.oauthConfig) {
+            this.oauthConfig.clientId = credentials.clientId || '';
+            this.oauthConfig.clientSecret = credentials.clientSecret || '';
+        }
+    }
+    // GitHub returns form-urlencoded by default; request JSON via Accept header
+    async exchangeCode(code) {
+        if (!this.oauthConfig)
+            throw new Error('GitHub OAuth not configured');
+        const body = new URLSearchParams({
+            client_id: this.oauthConfig.clientId,
+            client_secret: this.oauthConfig.clientSecret,
+            code,
+            redirect_uri: this.oauthConfig.redirectUri || this.redirectUri,
+        });
+        const resp = await fetch(this.oauthConfig.tokenUrl, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/x-www-form-urlencoded', 'Accept': 'application/json' },
+            body: body.toString(),
+        });
+        if (!resp.ok)
+            throw new Error(`GitHub token exchange failed (${resp.status})`);
+        const data = (await resp.json());
+        if (data.error)
+            throw new Error(`GitHub OAuth error: ${data.error_description || data.error}`);
+        if (data.expires_in && !data.expires_at)
+            data.expires_at = Date.now() + (Number(data.expires_in) * 1000);
+        this.tokenData = data;
+        return data;
+    }
+    // GitHub tokens are long-lived by default
+    async refreshAccessToken() {
+        if (this.tokenData?.refresh_token)
+            return super.refreshAccessToken();
+        if (this.tokenData?.access_token)
+            return this.tokenData;
+        throw new Error('GitHub token missing. Please reconnect.');
+    }
+    // GitHub requires Accept: application/vnd.github.v3+json
+    async apiRequest(url, options = {}) {
+        const token = await this.getAccessToken();
+        const headers = {
+            'Authorization': `Bearer ${token}`,
+            'Accept': 'application/vnd.github.v3+json',
+            'Content-Type': 'application/json',
+            ...(options.headers || {}),
+        };
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), 30000);
+        try {
+            let resp = await fetch(url, { ...options, headers, signal: controller.signal });
+            if (resp.status === 401) {
+                try {
+                    await this.refreshAccessToken();
+                    headers['Authorization'] = `Bearer ${this.tokenData.access_token}`;
+                    resp = await fetch(url, { ...options, headers, signal: controller.signal });
+                }
+                catch {
+                    throw new Error('GitHub authentication failed. Please reconnect.');
+                }
+            }
+            return resp;
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    async testConnection() {
+        const start = Date.now();
+        try {
+            const resp = await this.apiRequest('https://api.github.com/user');
+            if (!resp.ok)
+                return { success: false, message: `GitHub API returned ${resp.status}` };
+            const user = (await resp.json());
+            return { success: true, message: `Connected as ${user.login}`, latencyMs: Date.now() - start };
+        }
+        catch (err) {
+            return { success: false, message: `GitHub test failed: ${err instanceof Error ? err.message : String(err)}` };
+        }
+    }
+    // ── GitHub API ────────────────────────────────────────────────────────
+    async listRepos() {
+        const resp = await this.apiRequest('https://api.github.com/user/repos?sort=updated&per_page=20');
+        if (!resp.ok)
+            throw new Error(`GitHub list repos failed: ${resp.status}`);
+        return (await resp.json()).map(r => ({
+            name: r.full_name, description: r.description, isPrivate: r.private,
+            stars: r.stargazers_count, language: r.language, updated: r.updated_at, url: r.html_url,
+        }));
+    }
+    async listIssues(owner, repo, state = 'open') {
+        const resp = await this.apiRequest(`https://api.github.com/repos/${owner}/${repo}/issues?state=${state}&per_page=30`);
+        if (!resp.ok)
+            throw new Error(`GitHub list issues failed: ${resp.status}`);
+        return (await resp.json()).map(i => ({
+            number: i.number, title: i.title, state: i.state, author: i.user?.login || '',
+            labels: (i.labels || []).map(l => l.name), created: i.created_at, url: i.html_url,
+        }));
+    }
+    async createIssue(owner, repo, title, body) {
+        const resp = await this.apiRequest(`https://api.github.com/repos/${owner}/${repo}/issues`, {
+            method: 'POST', body: JSON.stringify({ title, body: body || '' }),
+        });
+        if (!resp.ok)
+            throw new Error(`GitHub create issue failed: ${await resp.text()}`);
+        const issue = (await resp.json());
+        return issue;
+    }
+    async listPRs(owner, repo, state = 'open') {
+        const resp = await this.apiRequest(`https://api.github.com/repos/${owner}/${repo}/pulls?state=${state}&per_page=30`);
+        if (!resp.ok)
+            throw new Error(`GitHub list PRs failed: ${resp.status}`);
+        return (await resp.json()).map(p => ({
+            number: p.number, title: p.title, state: p.state, author: p.user?.login || '',
+            head: p.head?.ref || '', base: p.base?.ref || '', draft: p.draft || false,
+            created: p.created_at, url: p.html_url,
+        }));
+    }
+    async createPR(owner, repo, title, body, head, base) {
+        const resp = await this.apiRequest(`https://api.github.com/repos/${owner}/${repo}/pulls`, {
+            method: 'POST', body: JSON.stringify({ title, body, head, base }),
+        });
+        if (!resp.ok)
+            throw new Error(`GitHub create PR failed: ${await resp.text()}`);
+        return (await resp.json());
+    }
+    async getFile(owner, repo, path) {
+        const resp = await this.apiRequest(`https://api.github.com/repos/${owner}/${repo}/contents/${path}`);
+        if (!resp.ok)
+            throw new Error(`GitHub get file failed: ${resp.status}`);
+        const data = (await resp.json());
+        const content = data.encoding === 'base64' && data.content
+            ? Buffer.from(data.content, 'base64').toString('utf-8')
+            : null;
+        return { name: data.name, path: data.path, size: data.size, sha: data.sha, content };
+    }
+    // ── Action interface ──────────────────────────────────────────────────
+    getActions() {
+        return [
+            { name: 'listRepos', description: "List the authenticated user's GitHub repositories.", parameters: {}, requiredParams: [] },
+            { name: 'listIssues', description: 'List issues for a GitHub repository.', parameters: { owner: { type: 'string', description: 'Repository owner' }, repo: { type: 'string', description: 'Repository name' }, state: { type: 'string', description: 'open, closed, or all' } }, requiredParams: ['owner', 'repo'] },
+            { name: 'createIssue', description: 'Create a new issue.', parameters: { owner: { type: 'string', description: 'Repository owner' }, repo: { type: 'string', description: 'Repository name' }, title: { type: 'string', description: 'Issue title' }, body: { type: 'string', description: 'Issue body (Markdown)' } }, requiredParams: ['owner', 'repo', 'title'] },
+            { name: 'listPRs', description: 'List pull requests.', parameters: { owner: { type: 'string', description: 'Repository owner' }, repo: { type: 'string', description: 'Repository name' }, state: { type: 'string', description: 'open, closed, or all' } }, requiredParams: ['owner', 'repo'] },
+            { name: 'createPR', description: 'Create a new pull request.', parameters: { owner: { type: 'string', description: 'Repository owner' }, repo: { type: 'string', description: 'Repository name' }, title: { type: 'string', description: 'PR title' }, body: { type: 'string', description: 'PR description' }, head: { type: 'string', description: 'Source branch' }, base: { type: 'string', description: 'Target branch' } }, requiredParams: ['owner', 'repo', 'title', 'head', 'base'] },
+            { name: 'getFile', description: 'Read a file from a GitHub repository.', parameters: { owner: { type: 'string', description: 'Repository owner' }, repo: { type: 'string', description: 'Repository name' }, path: { type: 'string', description: 'File path (e.g. "src/index.js")' } }, requiredParams: ['owner', 'repo', 'path'] },
+        ];
+    }
+    async executeAction(actionName, params) {
+        try {
+            switch (actionName) {
+                case 'listRepos': {
+                    const repos = await this.listRepos();
+                    if (repos.length === 0)
+                        return { success: true, output: 'No repositories found.' };
+                    const formatted = repos.map((r, i) => `${i + 1}. ${r.name}${r.isPrivate ? ' (private)' : ''} ${r.language ? `[${r.language}]` : ''}\n   ${r.description || '(no description)'}\n   Stars: ${r.stars} | Updated: ${r.updated}\n   ${r.url}`).join('\n\n');
+                    return { success: true, output: `${repos.length} repositories:\n\n${formatted}` };
+                }
+                case 'listIssues': {
+                    const issues = await this.listIssues(params.owner, params.repo, params.state || 'open');
+                    if (issues.length === 0)
+                        return { success: true, output: `No ${params.state || 'open'} issues found.` };
+                    const formatted = issues.map((i, idx) => `${idx + 1}. #${i.number} ${i.title} [${i.state}]\n   By: ${i.author} | Labels: ${i.labels.join(', ') || 'none'} | ${i.created}\n   ${i.url}`).join('\n\n');
+                    return { success: true, output: `${issues.length} issues:\n\n${formatted}` };
+                }
+                case 'createIssue': {
+                    const issue = await this.createIssue(params.owner, params.repo, params.title, params.body);
+                    return { success: true, output: `Issue #${issue.number} created: ${issue.title}\n${issue.html_url}` };
+                }
+                case 'listPRs': {
+                    const prs = await this.listPRs(params.owner, params.repo, params.state || 'open');
+                    if (prs.length === 0)
+                        return { success: true, output: `No ${params.state || 'open'} pull requests found.` };
+                    const formatted = prs.map((p, i) => `${i + 1}. #${p.number} ${p.title}${p.draft ? ' (draft)' : ''} [${p.state}]\n   ${p.head} -> ${p.base} | By: ${p.author} | ${p.created}\n   ${p.url}`).join('\n\n');
+                    return { success: true, output: `${prs.length} pull requests:\n\n${formatted}` };
+                }
+                case 'createPR': {
+                    const pr = await this.createPR(params.owner, params.repo, params.title, params.body || '', params.head, params.base);
+                    return { success: true, output: `PR #${pr.number} created: ${pr.title}\n${pr.html_url}` };
+                }
+                case 'getFile': {
+                    const file = await this.getFile(params.owner, params.repo, params.path);
+                    if (!file.content)
+                        return { success: true, output: `File ${file.path} exists (${file.size} bytes) but content could not be decoded.` };
+                    return { success: true, output: `File: ${file.path} (${file.size} bytes, SHA: ${file.sha})\n\n${file.content}` };
+                }
+                default:
+                    return { success: false, output: `Unknown GitHub action: ${actionName}` };
+            }
+        }
+        catch (err) {
+            return { success: false, output: `GitHub error: ${err instanceof Error ? err.message : String(err)}` };
+        }
+    }
+}

package/src/integrations/providers/GmailProvider.js

@@ -0,0 +1,204 @@
+/**
+ * Gmail Provider -- Google OAuth + Gmail API
+ * Actions: sendEmail, listInbox, replyToMessage, searchMessages
+ */
+import { BaseProvider } from './BaseProvider.js';
+export class GmailProvider extends BaseProvider {
+    constructor() {
+        super('gmail', 'Gmail', 'oauth2');
+        this.oauthConfig = {
+            authUrl: 'https://accounts.google.com/o/oauth2/v2/auth',
+            tokenUrl: 'https://oauth2.googleapis.com/token',
+            clientId: '',
+            clientSecret: '',
+            scopes: [
+                'https://www.googleapis.com/auth/gmail.send',
+                'https://www.googleapis.com/auth/gmail.readonly',
+                'https://www.googleapis.com/auth/gmail.modify',
+                'https://www.googleapis.com/auth/userinfo.email',
+            ],
+        };
+    }
+    getConfigFields() {
+        return [
+            { name: 'clientId', label: 'Google OAuth Client ID' },
+            { name: 'clientSecret', label: 'Google OAuth Client Secret', secret: true },
+        ];
+    }
+    async configure(credentials) {
+        if (this.oauthConfig) {
+            this.oauthConfig.clientId = credentials.clientId || '';
+            this.oauthConfig.clientSecret = credentials.clientSecret || '';
+        }
+    }
+    async testConnection() {
+        const start = Date.now();
+        try {
+            const resp = await this.apiRequest('https://gmail.googleapis.com/gmail/v1/users/me/profile');
+            if (!resp.ok)
+                return { success: false, message: `Gmail API returned ${resp.status}` };
+            const profile = (await resp.json());
+            return { success: true, message: `Connected as ${profile.emailAddress}`, latencyMs: Date.now() - start };
+        }
+        catch (err) {
+            return { success: false, message: `Gmail test failed: ${err instanceof Error ? err.message : String(err)}` };
+        }
+    }
+    // ── Gmail API methods ─────────────────────────────────────────────────
+    async sendEmail(to, subject, body, cc, bcc) {
+        const lines = [
+            `To: ${to}`,
+            cc ? `Cc: ${cc}` : null,
+            bcc ? `Bcc: ${bcc}` : null,
+            `Subject: ${subject}`,
+            'Content-Type: text/plain; charset=utf-8',
+            '',
+            body,
+        ].filter(Boolean);
+        const raw = Buffer.from(lines.join('\r\n')).toString('base64url');
+        const resp = await this.apiRequest('https://gmail.googleapis.com/gmail/v1/users/me/messages/send', {
+            method: 'POST',
+            body: JSON.stringify({ raw }),
+        });
+        if (!resp.ok) {
+            const err = await resp.text();
+            throw new Error(`Gmail send failed: ${err}`);
+        }
+        return (await resp.json());
+    }
+    async listMessages(query, maxResults = 20) {
+        const params = new URLSearchParams({ maxResults: String(Math.min(maxResults, 50)) });
+        if (query)
+            params.set('q', query);
+        const resp = await this.apiRequest(`https://gmail.googleapis.com/gmail/v1/users/me/messages?${params}`);
+        if (!resp.ok)
+            throw new Error(`Gmail list failed: ${resp.status}`);
+        const data = (await resp.json());
+        if (!data.messages || data.messages.length === 0)
+            return [];
+        const messages = [];
+        for (const msg of data.messages.slice(0, maxResults)) {
+            try {
+                const detail = await this.getMessage(msg.id, 'metadata');
+                messages.push(detail);
+            }
+            catch { /* skip failed messages */ }
+        }
+        return messages;
+    }
+    async getMessage(id, format = 'full') {
+        const resp = await this.apiRequest(`https://gmail.googleapis.com/gmail/v1/users/me/messages/${id}?format=${format}`);
+        if (!resp.ok)
+            throw new Error(`Gmail get failed: ${resp.status}`);
+        const msg = (await resp.json());
+        const headers = {};
+        for (const h of (msg.payload?.headers || [])) {
+            const name = h.name.toLowerCase();
+            if (['from', 'to', 'subject', 'date'].includes(name)) {
+                headers[name] = h.value;
+            }
+        }
+        return { id: msg.id, threadId: msg.threadId, snippet: msg.snippet, headers };
+    }
+    async replyToMessage(messageId, body) {
+        const original = await this.getMessage(messageId);
+        const subject = (original.headers.subject || '').startsWith('Re:')
+            ? original.headers.subject
+            : `Re: ${original.headers.subject || ''}`;
+        const to = original.headers.from;
+        const lines = [
+            `To: ${to}`,
+            `Subject: ${subject}`,
+            `In-Reply-To: <${messageId}>`,
+            `References: <${messageId}>`,
+            'Content-Type: text/plain; charset=utf-8',
+            '',
+            body,
+        ];
+        const raw = Buffer.from(lines.join('\r\n')).toString('base64url');
+        const resp = await this.apiRequest('https://gmail.googleapis.com/gmail/v1/users/me/messages/send', {
+            method: 'POST',
+            body: JSON.stringify({ raw, threadId: original.threadId }),
+        });
+        if (!resp.ok)
+            throw new Error(`Gmail reply failed: ${resp.status}`);
+        return (await resp.json());
+    }
+    // ── Action interface ──────────────────────────────────────────────────
+    getActions() {
+        return [
+            {
+                name: 'sendEmail',
+                description: 'Send an email via the connected Gmail account.',
+                parameters: {
+                    to: { type: 'string', description: 'Recipient email address' },
+                    subject: { type: 'string', description: 'Email subject line' },
+                    body: { type: 'string', description: 'Email body (plain text)' },
+                    cc: { type: 'string', description: 'CC recipients (comma-separated)' },
+                    bcc: { type: 'string', description: 'BCC recipients (comma-separated)' },
+                },
+                requiredParams: ['to', 'subject', 'body'],
+            },
+            {
+                name: 'listInbox',
+                description: 'List recent emails from the connected Gmail inbox.',
+                parameters: {
+                    count: { type: 'number', description: 'Number of messages (default 20, max 50)' },
+                    query: { type: 'string', description: 'Gmail search query (e.g. "is:unread from:boss@co.com")' },
+                },
+                requiredParams: [],
+            },
+            {
+                name: 'replyToMessage',
+                description: 'Reply to a specific email by message ID.',
+                parameters: {
+                    message_id: { type: 'string', description: 'Gmail message ID to reply to' },
+                    body: { type: 'string', description: 'Reply body text' },
+                },
+                requiredParams: ['message_id', 'body'],
+            },
+            {
+                name: 'searchMessages',
+                description: 'Search Gmail with a query string.',
+                parameters: {
+                    query: { type: 'string', description: 'Search query (Gmail search syntax)' },
+                    count: { type: 'number', description: 'Max results (default 10)' },
+                },
+                requiredParams: ['query'],
+            },
+        ];
+    }
+    async executeAction(actionName, params) {
+        try {
+            switch (actionName) {
+                case 'sendEmail': {
+                    const result = await this.sendEmail(params.to, params.subject, params.body, params.cc, params.bcc);
+                    return { success: true, output: `Email sent to ${params.to} (ID: ${result.id})` };
+                }
+                case 'listInbox': {
+                    const msgs = await this.listMessages(params.query, params.count || 20);
+                    if (msgs.length === 0)
+                        return { success: true, output: 'Inbox empty or no matches.' };
+                    const formatted = msgs.map((m, i) => `${i + 1}. [${m.headers.date || ''}] From: ${m.headers.from || '?'} -- ${m.headers.subject || '(no subject)'}\n   ${m.snippet || ''}\n   ID: ${m.id}`).join('\n\n');
+                    return { success: true, output: `${msgs.length} messages:\n\n${formatted}` };
+                }
+                case 'replyToMessage': {
+                    const result = await this.replyToMessage(params.message_id, params.body);
+                    return { success: true, output: `Reply sent (ID: ${result.id})` };
+                }
+                case 'searchMessages': {
+                    const msgs = await this.listMessages(params.query, params.count || 10);
+                    if (msgs.length === 0)
+                        return { success: true, output: `No results for: ${params.query}` };
+                    const formatted = msgs.map((m, i) => `${i + 1}. From: ${m.headers.from || '?'} -- ${m.headers.subject || '(no subject)'}\n   ${m.snippet || ''}\n   ID: ${m.id}`).join('\n\n');
+                    return { success: true, output: `${msgs.length} results:\n\n${formatted}` };
+                }
+                default:
+                    return { success: false, output: `Unknown Gmail action: ${actionName}` };
+            }
+        }
+        catch (err) {
+            return { success: false, output: `Gmail error: ${err instanceof Error ? err.message : String(err)}` };
+        }
+    }
+}

package/src/integrations/providers/GoogleCalendarProvider.js

@@ -0,0 +1,113 @@
+/**
+ * Google Calendar Provider -- Google OAuth + Calendar API
+ * Actions: listEvents, createEvent, deleteEvent
+ */
+import { BaseProvider } from './BaseProvider.js';
+export class GoogleCalendarProvider extends BaseProvider {
+    constructor() {
+        super('google-calendar', 'Google Calendar', 'oauth2');
+        this.oauthConfig = {
+            authUrl: 'https://accounts.google.com/o/oauth2/v2/auth',
+            tokenUrl: 'https://oauth2.googleapis.com/token',
+            clientId: '',
+            clientSecret: '',
+            scopes: ['https://www.googleapis.com/auth/calendar', 'https://www.googleapis.com/auth/calendar.events'],
+        };
+    }
+    getConfigFields() {
+        return [
+            { name: 'clientId', label: 'Google OAuth Client ID' },
+            { name: 'clientSecret', label: 'Google OAuth Client Secret', secret: true },
+        ];
+    }
+    async configure(credentials) {
+        if (this.oauthConfig) {
+            this.oauthConfig.clientId = credentials.clientId || '';
+            this.oauthConfig.clientSecret = credentials.clientSecret || '';
+        }
+    }
+    async testConnection() {
+        const start = Date.now();
+        try {
+            const resp = await this.apiRequest('https://www.googleapis.com/calendar/v3/calendars/primary');
+            if (!resp.ok)
+                return { success: false, message: `Calendar API returned ${resp.status}` };
+            const cal = (await resp.json());
+            return { success: true, message: `Connected to calendar: ${cal.summary || 'primary'}`, latencyMs: Date.now() - start };
+        }
+        catch (err) {
+            return { success: false, message: `Calendar test failed: ${err instanceof Error ? err.message : String(err)}` };
+        }
+    }
+    async listEvents(timeMin, timeMax, maxResults = 20, calendarId = 'primary') {
+        const params = new URLSearchParams({ maxResults: String(maxResults), singleEvents: 'true', orderBy: 'startTime' });
+        if (timeMin)
+            params.set('timeMin', new Date(timeMin).toISOString());
+        if (timeMax)
+            params.set('timeMax', new Date(timeMax).toISOString());
+        const resp = await this.apiRequest(`https://www.googleapis.com/calendar/v3/calendars/${encodeURIComponent(calendarId)}/events?${params}`);
+        if (!resp.ok)
+            throw new Error(`Calendar list failed: ${resp.status}`);
+        const data = (await resp.json());
+        return (data.items || []).map(e => ({
+            id: e.id, summary: e.summary || '(no title)',
+            start: e.start?.dateTime || e.start?.date || '', end: e.end?.dateTime || e.end?.date || '',
+            location: e.location || '', description: e.description || '',
+        }));
+    }
+    async createEvent(summary, start, end, location, description) {
+        const event = {
+            summary,
+            start: { dateTime: new Date(start).toISOString() },
+            end: { dateTime: new Date(end).toISOString() },
+        };
+        if (location)
+            event.location = location;
+        if (description)
+            event.description = description;
+        const resp = await this.apiRequest('https://www.googleapis.com/calendar/v3/calendars/primary/events', {
+            method: 'POST', body: JSON.stringify(event),
+        });
+        if (!resp.ok)
+            throw new Error(`Calendar create failed: ${resp.status}`);
+        return (await resp.json());
+    }
+    async deleteEvent(eventId) {
+        const resp = await this.apiRequest(`https://www.googleapis.com/calendar/v3/calendars/primary/events/${eventId}`, { method: 'DELETE' });
+        if (!resp.ok && resp.status !== 204)
+            throw new Error(`Calendar delete failed: ${resp.status}`);
+    }
+    getActions() {
+        return [
+            { name: 'listEvents', description: 'List upcoming events from Google Calendar.', parameters: { start_date: { type: 'string', description: 'Start of range (ISO 8601)' }, end_date: { type: 'string', description: 'End of range (ISO 8601)' }, count: { type: 'number', description: 'Max events (default 20)' } }, requiredParams: [] },
+            { name: 'createEvent', description: 'Create a new calendar event.', parameters: { title: { type: 'string', description: 'Event title' }, start: { type: 'string', description: 'Start date/time (ISO 8601)' }, end: { type: 'string', description: 'End date/time (ISO 8601)' }, location: { type: 'string', description: 'Event location' }, description: { type: 'string', description: 'Event description' } }, requiredParams: ['title', 'start', 'end'] },
+            { name: 'deleteEvent', description: 'Delete a calendar event by ID.', parameters: { event_id: { type: 'string', description: 'Event ID to delete' } }, requiredParams: ['event_id'] },
+        ];
+    }
+    async executeAction(actionName, params) {
+        try {
+            switch (actionName) {
+                case 'listEvents': {
+                    const events = await this.listEvents(params.start_date, params.end_date, params.count || 20);
+                    if (events.length === 0)
+                        return { success: true, output: 'No events found in range.' };
+                    const formatted = events.map((e, i) => `${i + 1}. ${e.summary}  |  ${e.start} - ${e.end}${e.location ? '  |  ' + e.location : ''}\n   ID: ${e.id}`).join('\n');
+                    return { success: true, output: `${events.length} events:\n${formatted}` };
+                }
+                case 'createEvent': {
+                    const result = await this.createEvent(params.title, params.start, params.end, params.location, params.description);
+                    return { success: true, output: `Event created: "${params.title}" (ID: ${result.id})` };
+                }
+                case 'deleteEvent': {
+                    await this.deleteEvent(params.event_id);
+                    return { success: true, output: `Event deleted: ${params.event_id}` };
+                }
+                default:
+                    return { success: false, output: `Unknown calendar action: ${actionName}` };
+            }
+        }
+        catch (err) {
+            return { success: false, output: `Calendar error: ${err instanceof Error ? err.message : String(err)}` };
+        }
+    }
+}