thaddeus 1.0.26 → 1.0.28

package/src/integrations/providers/HubSpotProvider.js

@@ -0,0 +1,159 @@
+/**
+ * HubSpot CRM Provider -- OAuth-based
+ * Actions: listContacts, createContact, listDeals, createDeal, searchContacts
+ */
+import { BaseProvider } from './BaseProvider.js';
+const API_BASE = 'https://api.hubapi.com';
+export class HubSpotProvider extends BaseProvider {
+    constructor() {
+        super('hubspot', 'HubSpot CRM', 'oauth2');
+        this.oauthConfig = {
+            authUrl: 'https://app.hubspot.com/oauth/authorize',
+            tokenUrl: 'https://api.hubapi.com/oauth/v1/token',
+            clientId: '',
+            clientSecret: '',
+            scopes: ['crm.objects.contacts.read', 'crm.objects.contacts.write', 'crm.objects.deals.read', 'crm.objects.deals.write', 'crm.objects.companies.read'],
+        };
+    }
+    getConfigFields() {
+        return [
+            { name: 'clientId', label: 'HubSpot App Client ID' },
+            { name: 'clientSecret', label: 'HubSpot App 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(`${API_BASE}/crm/v3/objects/contacts?limit=1`);
+            if (!resp.ok)
+                return { success: false, message: `HubSpot API returned ${resp.status}` };
+            return { success: true, message: 'HubSpot CRM connected', latencyMs: Date.now() - start };
+        }
+        catch (err) {
+            return { success: false, message: `HubSpot test failed: ${err instanceof Error ? err.message : String(err)}` };
+        }
+    }
+    async listContacts(limit = 20) {
+        const resp = await this.apiRequest(`${API_BASE}/crm/v3/objects/contacts?limit=${limit}&properties=email,firstname,lastname,phone`);
+        if (!resp.ok)
+            throw new Error(`HubSpot list contacts failed: ${resp.status}`);
+        const data = (await resp.json());
+        return (data.results || []).map(c => ({
+            id: c.id, email: c.properties?.email || '', firstName: c.properties?.firstname || '',
+            lastName: c.properties?.lastname || '', phone: c.properties?.phone || '', createdAt: c.createdAt || '',
+        }));
+    }
+    async createContact(props) {
+        const properties = {};
+        if (props.email)
+            properties.email = props.email;
+        if (props.firstName)
+            properties.firstname = props.firstName;
+        if (props.lastName)
+            properties.lastname = props.lastName;
+        if (props.phone)
+            properties.phone = props.phone;
+        if (props.company)
+            properties.company = props.company;
+        const resp = await this.apiRequest(`${API_BASE}/crm/v3/objects/contacts`, {
+            method: 'POST', body: JSON.stringify({ properties }),
+        });
+        if (!resp.ok)
+            throw new Error(`HubSpot create contact failed: ${await resp.text()}`);
+        return (await resp.json());
+    }
+    async listDeals(limit = 20) {
+        const resp = await this.apiRequest(`${API_BASE}/crm/v3/objects/deals?limit=${limit}&properties=dealname,amount,dealstage`);
+        if (!resp.ok)
+            throw new Error(`HubSpot list deals failed: ${resp.status}`);
+        const data = (await resp.json());
+        return (data.results || []).map(d => ({
+            id: d.id, name: d.properties?.dealname || '', amount: d.properties?.amount || '0',
+            stage: d.properties?.dealstage || '', createdAt: d.createdAt || '',
+        }));
+    }
+    async createDeal(props) {
+        const properties = {};
+        if (props.dealName)
+            properties.dealname = props.dealName;
+        if (props.amount !== undefined)
+            properties.amount = String(props.amount);
+        if (props.pipeline)
+            properties.pipeline = props.pipeline;
+        if (props.stage)
+            properties.dealstage = props.stage;
+        const resp = await this.apiRequest(`${API_BASE}/crm/v3/objects/deals`, {
+            method: 'POST', body: JSON.stringify({ properties }),
+        });
+        if (!resp.ok)
+            throw new Error(`HubSpot create deal failed: ${await resp.text()}`);
+        return (await resp.json());
+    }
+    async searchContacts(query) {
+        const resp = await this.apiRequest(`${API_BASE}/crm/v3/objects/contacts/search`, {
+            method: 'POST', body: JSON.stringify({ query, limit: 20, properties: ['email', 'firstname', 'lastname', 'phone'] }),
+        });
+        if (!resp.ok)
+            throw new Error(`HubSpot search contacts failed: ${resp.status}`);
+        const data = (await resp.json());
+        return (data.results || []).map(c => ({
+            id: c.id, email: c.properties?.email || '', firstName: c.properties?.firstname || '',
+            lastName: c.properties?.lastname || '', phone: c.properties?.phone || '',
+        }));
+    }
+    getActions() {
+        return [
+            { name: 'listContacts', description: 'List contacts from HubSpot CRM.', parameters: { count: { type: 'number', description: 'Number of contacts (default 20)' } }, requiredParams: [] },
+            { name: 'createContact', description: 'Create a new CRM contact.', parameters: { email: { type: 'string', description: 'Email address' }, firstName: { type: 'string', description: 'First name' }, lastName: { type: 'string', description: 'Last name' }, phone: { type: 'string', description: 'Phone number' }, company: { type: 'string', description: 'Company name' } }, requiredParams: ['email'] },
+            { name: 'listDeals', description: 'List deals from HubSpot CRM.', parameters: { count: { type: 'number', description: 'Number of deals (default 20)' } }, requiredParams: [] },
+            { name: 'createDeal', description: 'Create a new deal.', parameters: { dealName: { type: 'string', description: 'Deal name' }, amount: { type: 'number', description: 'Deal amount in dollars' }, pipeline: { type: 'string', description: 'Pipeline' }, stage: { type: 'string', description: 'Deal stage' } }, requiredParams: ['dealName'] },
+            { name: 'searchContacts', description: 'Search HubSpot contacts.', parameters: { query: { type: 'string', description: 'Search query' } }, requiredParams: ['query'] },
+        ];
+    }
+    async executeAction(actionName, params) {
+        try {
+            switch (actionName) {
+                case 'listContacts': {
+                    const contacts = await this.listContacts(params.count || 20);
+                    if (contacts.length === 0)
+                        return { success: true, output: 'No contacts found.' };
+                    const formatted = contacts.map((c, i) => `${i + 1}. ${c.firstName} ${c.lastName} -- ${c.email || '(no email)'}\n   Phone: ${c.phone || 'N/A'}  |  ID: ${c.id}`).join('\n\n');
+                    return { success: true, output: `${contacts.length} contacts:\n\n${formatted}` };
+                }
+                case 'createContact': {
+                    const result = await this.createContact(params);
+                    return { success: true, output: `Contact created! ID: ${result.id}\n  Email: ${params.email}\n  Name: ${params.firstName || ''} ${params.lastName || ''}`.trim() };
+                }
+                case 'listDeals': {
+                    const deals = await this.listDeals(params.count || 20);
+                    if (deals.length === 0)
+                        return { success: true, output: 'No deals found.' };
+                    const formatted = deals.map((d, i) => `${i + 1}. ${d.name || '(unnamed)'} -- $${d.amount} -- Stage: ${d.stage || 'N/A'}\n   ID: ${d.id}  |  Created: ${d.createdAt}`).join('\n\n');
+                    return { success: true, output: `${deals.length} deals:\n\n${formatted}` };
+                }
+                case 'createDeal': {
+                    const result = await this.createDeal(params);
+                    return { success: true, output: `Deal created! ID: ${result.id}\n  Name: ${params.dealName}\n  Amount: $${params.amount || 0}` };
+                }
+                case 'searchContacts': {
+                    const results = await this.searchContacts(params.query);
+                    if (results.length === 0)
+                        return { success: true, output: `No contacts found for "${params.query}".` };
+                    const formatted = results.map((c, i) => `${i + 1}. ${c.firstName} ${c.lastName} -- ${c.email || '(no email)'}\n   Phone: ${c.phone || 'N/A'}  |  ID: ${c.id}`).join('\n\n');
+                    return { success: true, output: `${results.length} contacts matching "${params.query}":\n\n${formatted}` };
+                }
+                default:
+                    return { success: false, output: `Unknown HubSpot action: ${actionName}` };
+            }
+        }
+        catch (err) {
+            return { success: false, output: `HubSpot error: ${err instanceof Error ? err.message : String(err)}` };
+        }
+    }
+}

package/src/integrations/providers/JiraProvider.js

@@ -0,0 +1,216 @@
+/**
+ * Jira Provider -- Atlassian OAuth 2.0 (3LO) + Jira REST API v3
+ * Actions: listProjects, createIssue, getIssue, updateIssue, searchIssues
+ */
+import { BaseProvider } from './BaseProvider.js';
+export class JiraProvider extends BaseProvider {
+    cloudId = null;
+    constructor() {
+        super('jira', 'Jira', 'oauth2');
+        this.oauthConfig = {
+            authUrl: 'https://auth.atlassian.com/authorize',
+            tokenUrl: 'https://auth.atlassian.com/oauth/token',
+            clientId: '',
+            clientSecret: '',
+            scopes: ['read:jira-work', 'write:jira-work', 'read:jira-user', 'offline_access'],
+        };
+    }
+    getConfigFields() {
+        return [
+            { name: 'clientId', label: 'Atlassian OAuth App Client ID' },
+            { name: 'clientSecret', label: 'Atlassian OAuth App Client Secret', secret: true },
+        ];
+    }
+    async configure(credentials) {
+        if (this.oauthConfig) {
+            this.oauthConfig.clientId = credentials.clientId || '';
+            this.oauthConfig.clientSecret = credentials.clientSecret || '';
+        }
+    }
+    // Atlassian uses audience param
+    getAuthorizationUrl(state) {
+        if (!this.oauthConfig)
+            throw new Error('Jira OAuth not configured');
+        const params = new URLSearchParams({
+            audience: 'api.atlassian.com',
+            client_id: this.oauthConfig.clientId,
+            scope: this.oauthConfig.scopes.join(' '),
+            redirect_uri: this.oauthConfig.redirectUri || this.redirectUri,
+            state,
+            response_type: 'code',
+            prompt: 'consent',
+        });
+        return `${this.oauthConfig.authUrl}?${params.toString()}`;
+    }
+    // Atlassian token exchange uses JSON body
+    async exchangeCode(code) {
+        if (!this.oauthConfig)
+            throw new Error('Jira OAuth not configured');
+        const resp = await fetch(this.oauthConfig.tokenUrl, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                grant_type: 'authorization_code',
+                client_id: this.oauthConfig.clientId,
+                client_secret: this.oauthConfig.clientSecret,
+                code,
+                redirect_uri: this.oauthConfig.redirectUri || this.redirectUri,
+            }),
+        });
+        if (!resp.ok)
+            throw new Error(`Jira token exchange failed (${resp.status})`);
+        const data = (await resp.json());
+        if (data.expires_in && !data.expires_at)
+            data.expires_at = Date.now() + (Number(data.expires_in) * 1000);
+        this.tokenData = data;
+        return data;
+    }
+    async refreshAccessToken() {
+        if (!this.oauthConfig)
+            throw new Error('Jira OAuth not configured');
+        if (!this.tokenData?.refresh_token)
+            throw new Error('No refresh token for Jira');
+        const resp = await fetch(this.oauthConfig.tokenUrl, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                grant_type: 'refresh_token',
+                client_id: this.oauthConfig.clientId,
+                client_secret: this.oauthConfig.clientSecret,
+                refresh_token: this.tokenData.refresh_token,
+            }),
+        });
+        if (!resp.ok)
+            throw new Error(`Jira token refresh failed (${resp.status})`);
+        const data = (await resp.json());
+        const merged = {
+            ...this.tokenData, ...data,
+            refresh_token: data.refresh_token || this.tokenData.refresh_token,
+            expires_at: Date.now() + (Number(data.expires_in || 3600) * 1000),
+        };
+        this.tokenData = merged;
+        return merged;
+    }
+    async getCloudId() {
+        if (this.cloudId)
+            return this.cloudId;
+        const token = await this.getAccessToken();
+        const resp = await fetch('https://api.atlassian.com/oauth/token/accessible-resources', {
+            headers: { 'Authorization': `Bearer ${token}`, 'Accept': 'application/json' },
+        });
+        if (!resp.ok)
+            throw new Error(`Jira accessible-resources failed: ${resp.status}`);
+        const sites = (await resp.json());
+        if (!sites?.length)
+            throw new Error('No Jira sites accessible');
+        this.cloudId = sites[0].id;
+        return this.cloudId;
+    }
+    async baseUrl() {
+        const cloudId = await this.getCloudId();
+        return `https://api.atlassian.com/ex/jira/${cloudId}/rest`;
+    }
+    async testConnection() {
+        const start = Date.now();
+        try {
+            const base = await this.baseUrl();
+            const resp = await this.apiRequest(`${base}/api/3/myself`);
+            if (!resp.ok)
+                return { success: false, message: `Jira API returned ${resp.status}` };
+            const user = (await resp.json());
+            return { success: true, message: `Connected as ${user.displayName || 'unknown'}`, latencyMs: Date.now() - start };
+        }
+        catch (err) {
+            return { success: false, message: `Jira test failed: ${err instanceof Error ? err.message : String(err)}` };
+        }
+    }
+    async listProjects() {
+        const base = await this.baseUrl();
+        const resp = await this.apiRequest(`${base}/api/3/project/search?maxResults=50`);
+        if (!resp.ok)
+            throw new Error(`Jira list projects failed: ${resp.status}`);
+        const data = (await resp.json());
+        return (data.values || []).map(p => ({ id: p.id, key: p.key, name: p.name, style: p.style || '' }));
+    }
+    async createIssue(projectKey, summary, issueType, description) {
+        const base = await this.baseUrl();
+        const fields = {
+            project: { key: projectKey }, summary, issuetype: { name: issueType || 'Task' },
+        };
+        if (description) {
+            fields.description = { type: 'doc', version: 1, content: [{ type: 'paragraph', content: [{ type: 'text', text: description }] }] };
+        }
+        const resp = await this.apiRequest(`${base}/api/3/issue`, { method: 'POST', body: JSON.stringify({ fields }) });
+        if (!resp.ok)
+            throw new Error(`Jira create issue failed: ${await resp.text()}`);
+        return (await resp.json());
+    }
+    async getIssue(issueKey) {
+        const base = await this.baseUrl();
+        const resp = await this.apiRequest(`${base}/api/3/issue/${issueKey}`);
+        if (!resp.ok)
+            throw new Error(`Jira get issue failed: ${resp.status}`);
+        const d = (await resp.json());
+        return {
+            key: d.key, id: d.id, summary: d.fields?.summary || '',
+            status: d.fields?.status?.name || '', assignee: d.fields?.assignee?.displayName || 'Unassigned',
+            priority: d.fields?.priority?.name || '', type: d.fields?.issuetype?.name || '',
+            created: d.fields?.created || '', updated: d.fields?.updated || '',
+        };
+    }
+    async searchIssues(jql, maxResults = 25) {
+        const base = await this.baseUrl();
+        const resp = await this.apiRequest(`${base}/api/3/search`, {
+            method: 'POST', body: JSON.stringify({ jql, maxResults, fields: ['summary', 'status', 'assignee', 'priority', 'issuetype'] }),
+        });
+        if (!resp.ok)
+            throw new Error(`Jira search failed: ${resp.status}`);
+        const data = (await resp.json());
+        return (data.issues || []).map(i => ({
+            key: i.key, summary: i.fields?.summary || '', status: i.fields?.status?.name || '',
+            assignee: i.fields?.assignee?.displayName || 'Unassigned', priority: i.fields?.priority?.name || '',
+            type: i.fields?.issuetype?.name || '',
+        }));
+    }
+    getActions() {
+        return [
+            { name: 'listProjects', description: 'List all Jira projects.', parameters: {}, requiredParams: [] },
+            { name: 'createIssue', description: 'Create a new Jira issue.', parameters: { project_key: { type: 'string', description: 'Project key (e.g. PROJ)' }, summary: { type: 'string', description: 'Issue title' }, issue_type: { type: 'string', description: 'Task, Bug, Story, Epic (default Task)' }, description: { type: 'string', description: 'Description' } }, requiredParams: ['project_key', 'summary'] },
+            { name: 'getIssue', description: 'Get full details of a Jira issue.', parameters: { issue_key: { type: 'string', description: 'Issue key (e.g. PROJ-123)' } }, requiredParams: ['issue_key'] },
+            { name: 'searchIssues', description: 'Search Jira issues using JQL.', parameters: { jql: { type: 'string', description: 'JQL query' }, max_results: { type: 'number', description: 'Max results (default 25)' } }, requiredParams: ['jql'] },
+        ];
+    }
+    async executeAction(actionName, params) {
+        try {
+            switch (actionName) {
+                case 'listProjects': {
+                    const projects = await this.listProjects();
+                    if (projects.length === 0)
+                        return { success: true, output: 'No projects found.' };
+                    const formatted = projects.map((p, i) => `${i + 1}. ${p.key} -- ${p.name} (${p.style || 'classic'})`).join('\n');
+                    return { success: true, output: `${projects.length} projects:\n\n${formatted}` };
+                }
+                case 'createIssue': {
+                    const result = await this.createIssue(params.project_key, params.summary, params.issue_type, params.description);
+                    return { success: true, output: `Issue created: ${result.key} (ID: ${result.id})` };
+                }
+                case 'getIssue': {
+                    const issue = await this.getIssue(params.issue_key);
+                    return { success: true, output: `${issue.key} -- ${issue.summary}\nType: ${issue.type}  |  Status: ${issue.status}  |  Priority: ${issue.priority}\nAssignee: ${issue.assignee}\nCreated: ${issue.created}  |  Updated: ${issue.updated}` };
+                }
+                case 'searchIssues': {
+                    const issues = await this.searchIssues(params.jql, params.max_results || 25);
+                    if (issues.length === 0)
+                        return { success: true, output: 'No issues match that query.' };
+                    const formatted = issues.map((i, idx) => `${idx + 1}. ${i.key} -- ${i.summary}\n   Status: ${i.status}  |  Type: ${i.type}  |  Priority: ${i.priority}  |  Assignee: ${i.assignee}`).join('\n\n');
+                    return { success: true, output: `${issues.length} issues:\n\n${formatted}` };
+                }
+                default:
+                    return { success: false, output: `Unknown Jira action: ${actionName}` };
+            }
+        }
+        catch (err) {
+            return { success: false, output: `Jira error: ${err instanceof Error ? err.message : String(err)}` };
+        }
+    }
+}

package/src/integrations/providers/NotionProvider.js

@@ -0,0 +1,221 @@
+/**
+ * Notion Provider -- Notion OAuth + API
+ * Actions: search, getPage, createPage, updatePage, queryDatabase
+ */
+import { BaseProvider } from './BaseProvider.js';
+export class NotionProvider extends BaseProvider {
+    constructor() {
+        super('notion', 'Notion', 'oauth2');
+        this.oauthConfig = {
+            authUrl: 'https://api.notion.com/v1/oauth/authorize',
+            tokenUrl: 'https://api.notion.com/v1/oauth/token',
+            clientId: '',
+            clientSecret: '',
+            scopes: [],
+        };
+    }
+    getConfigFields() {
+        return [
+            { name: 'clientId', label: 'Notion Integration Client ID' },
+            { name: 'clientSecret', label: 'Notion Integration Client Secret', secret: true },
+        ];
+    }
+    async configure(credentials) {
+        if (this.oauthConfig) {
+            this.oauthConfig.clientId = credentials.clientId || '';
+            this.oauthConfig.clientSecret = credentials.clientSecret || '';
+        }
+    }
+    // Notion uses owner=user and no scope param
+    getAuthorizationUrl(state) {
+        if (!this.oauthConfig)
+            throw new Error('Notion OAuth not configured');
+        const params = new URLSearchParams({
+            client_id: this.oauthConfig.clientId,
+            redirect_uri: this.oauthConfig.redirectUri || this.redirectUri,
+            response_type: 'code',
+            owner: 'user',
+            state,
+        });
+        return `${this.oauthConfig.authUrl}?${params.toString()}`;
+    }
+    // Notion token exchange uses Basic auth and JSON body
+    async exchangeCode(code) {
+        if (!this.oauthConfig)
+            throw new Error('Notion OAuth not configured');
+        const credentials = Buffer.from(`${this.oauthConfig.clientId}:${this.oauthConfig.clientSecret}`).toString('base64');
+        const resp = await fetch(this.oauthConfig.tokenUrl, {
+            method: 'POST',
+            headers: { 'Authorization': `Basic ${credentials}`, 'Content-Type': 'application/json' },
+            body: JSON.stringify({ grant_type: 'authorization_code', code, redirect_uri: this.oauthConfig.redirectUri || this.redirectUri }),
+        });
+        if (!resp.ok)
+            throw new Error(`Notion token exchange failed (${resp.status})`);
+        const data = (await resp.json());
+        if (data.error)
+            throw new Error(`Notion OAuth error: ${data.error}`);
+        this.tokenData = data;
+        return data;
+    }
+    // Notion tokens are long-lived -- no refresh
+    async refreshAccessToken() {
+        if (this.tokenData?.access_token)
+            return this.tokenData;
+        throw new Error('Notion token missing. Please reconnect.');
+    }
+    // Notion requires Notion-Version header
+    async apiRequest(url, options = {}) {
+        const token = await this.getAccessToken();
+        const headers = {
+            'Authorization': `Bearer ${token}`,
+            'Content-Type': 'application/json',
+            'Notion-Version': '2022-06-28',
+            ...(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.loadCredentials(this.tokenData);
+                    headers['Authorization'] = `Bearer ${this.tokenData.access_token}`;
+                    resp = await fetch(url, { ...options, headers, signal: controller.signal });
+                }
+                catch {
+                    throw new Error('Notion authentication failed. Please reconnect.');
+                }
+            }
+            return resp;
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    async testConnection() {
+        const start = Date.now();
+        try {
+            const resp = await this.apiRequest('https://api.notion.com/v1/search', { method: 'POST', body: JSON.stringify({ page_size: 1 }) });
+            if (!resp.ok)
+                return { success: false, message: `Notion API returned ${resp.status}` };
+            return { success: true, message: 'Notion workspace connected', latencyMs: Date.now() - start };
+        }
+        catch (err) {
+            return { success: false, message: `Notion test failed: ${err instanceof Error ? err.message : String(err)}` };
+        }
+    }
+    extractPageTitle(page) {
+        const properties = page.properties;
+        if (!properties)
+            return '(untitled)';
+        for (const prop of Object.values(properties)) {
+            if (prop.type === 'title' && prop.title)
+                return prop.title.map(t => t.plain_text).join('') || '(untitled)';
+        }
+        return '(untitled)';
+    }
+    async search(query, filter, pageSize = 20) {
+        const body = { page_size: Math.min(pageSize, 100) };
+        if (query)
+            body.query = query;
+        if (filter)
+            body.filter = { value: filter, property: 'object' };
+        const resp = await this.apiRequest('https://api.notion.com/v1/search', { method: 'POST', body: JSON.stringify(body) });
+        if (!resp.ok)
+            throw new Error(`Notion search failed: ${resp.status}`);
+        const data = (await resp.json());
+        return (data.results || []).map(item => ({
+            id: item.id,
+            type: item.object,
+            title: this.extractPageTitle(item),
+            url: item.url,
+            updated: item.last_edited_time,
+        }));
+    }
+    async getPage(pageId) {
+        const resp = await this.apiRequest(`https://api.notion.com/v1/pages/${pageId}`);
+        if (!resp.ok)
+            throw new Error(`Notion get page failed: ${resp.status}`);
+        return (await resp.json());
+    }
+    async createPage(databaseId, properties, children) {
+        const body = { parent: { database_id: databaseId }, properties: properties || {} };
+        if (children?.length)
+            body.children = children;
+        const resp = await this.apiRequest('https://api.notion.com/v1/pages', { method: 'POST', body: JSON.stringify(body) });
+        if (!resp.ok)
+            throw new Error(`Notion create page failed: ${await resp.text()}`);
+        return (await resp.json());
+    }
+    async updatePage(pageId, properties) {
+        const resp = await this.apiRequest(`https://api.notion.com/v1/pages/${pageId}`, {
+            method: 'PATCH', body: JSON.stringify({ properties: properties || {} }),
+        });
+        if (!resp.ok)
+            throw new Error(`Notion update page failed: ${await resp.text()}`);
+        return (await resp.json());
+    }
+    async queryDatabase(databaseId, filter, sorts, pageSize = 20) {
+        const body = { page_size: Math.min(pageSize, 100) };
+        if (filter)
+            body.filter = filter;
+        if (sorts)
+            body.sorts = sorts;
+        const resp = await this.apiRequest(`https://api.notion.com/v1/databases/${databaseId}/query`, { method: 'POST', body: JSON.stringify(body) });
+        if (!resp.ok)
+            throw new Error(`Notion query database failed: ${resp.status}`);
+        return (await resp.json());
+    }
+    getActions() {
+        return [
+            { name: 'search', description: 'Search across pages and databases in Notion.', parameters: { query: { type: 'string', description: 'Search query' }, filter: { type: 'string', description: 'Filter: "page" or "database"' }, page_size: { type: 'number', description: 'Max results (default 20)' } }, requiredParams: [] },
+            { name: 'getPage', description: 'Get a Notion page by ID.', parameters: { page_id: { type: 'string', description: 'Page ID (UUID)' } }, requiredParams: ['page_id'] },
+            { name: 'createPage', description: 'Create a page in a Notion database.', parameters: { database_id: { type: 'string', description: 'Parent database ID' }, properties: { type: 'object', description: 'Page properties matching database schema' } }, requiredParams: ['database_id', 'properties'] },
+            { name: 'updatePage', description: 'Update properties of a Notion page.', parameters: { page_id: { type: 'string', description: 'Page ID' }, properties: { type: 'object', description: 'Properties to update' } }, requiredParams: ['page_id', 'properties'] },
+            { name: 'queryDatabase', description: 'Query a Notion database with filters.', parameters: { database_id: { type: 'string', description: 'Database ID' }, filter: { type: 'object', description: 'Notion filter object' }, sorts: { type: 'array', description: 'Sort objects' }, page_size: { type: 'number', description: 'Max results' } }, requiredParams: ['database_id'] },
+        ];
+    }
+    async executeAction(actionName, params) {
+        try {
+            switch (actionName) {
+                case 'search': {
+                    const results = await this.search(params.query, params.filter, params.page_size || 20);
+                    if (results.length === 0)
+                        return { success: true, output: 'No results found.' };
+                    const formatted = results.map((r, i) => `${i + 1}. [${r.type}] ${r.title}\n   ID: ${r.id}\n   Updated: ${r.updated}\n   ${r.url}`).join('\n\n');
+                    return { success: true, output: `${results.length} results:\n\n${formatted}` };
+                }
+                case 'getPage': {
+                    const page = await this.getPage(params.page_id);
+                    const title = this.extractPageTitle(page);
+                    return { success: true, output: `Page: ${title}\nID: ${page.id}\nURL: ${page.url}` };
+                }
+                case 'createPage': {
+                    const page = await this.createPage(params.database_id, params.properties, params.children);
+                    const title = this.extractPageTitle(page);
+                    return { success: true, output: `Page created: ${title}\nID: ${page.id}\nURL: ${page.url}` };
+                }
+                case 'updatePage': {
+                    const page = await this.updatePage(params.page_id, params.properties);
+                    const title = this.extractPageTitle(page);
+                    return { success: true, output: `Page updated: ${title}\nID: ${page.id}\nURL: ${page.url}` };
+                }
+                case 'queryDatabase': {
+                    const data = await this.queryDatabase(params.database_id, params.filter, params.sorts, params.page_size || 20);
+                    if (!data.results?.length)
+                        return { success: true, output: 'No matching pages in database.' };
+                    const formatted = data.results.map((page, i) => {
+                        const title = this.extractPageTitle(page);
+                        return `${i + 1}. ${title}\n   ID: ${page.id}`;
+                    }).join('\n\n');
+                    return { success: true, output: `${data.results.length} pages:\n\n${formatted}` };
+                }
+                default:
+                    return { success: false, output: `Unknown Notion action: ${actionName}` };
+            }
+        }
+        catch (err) {
+            return { success: false, output: `Notion error: ${err instanceof Error ? err.message : String(err)}` };
+        }
+    }
+}