thaddeus 1.0.26 → 1.0.28

package/src/integrations/providers/QuickBooksProvider.js

@@ -0,0 +1,176 @@
+/**
+ * QuickBooks Provider -- OAuth-based with realmId (company ID)
+ * Actions: listInvoices, createInvoice, listCustomers, getBalance
+ */
+import { BaseProvider } from './BaseProvider.js';
+export class QuickBooksProvider extends BaseProvider {
+    realmId = null;
+    constructor() {
+        super('quickbooks', 'QuickBooks', 'oauth2');
+        this.oauthConfig = {
+            authUrl: 'https://appcenter.intuit.com/connect/oauth2',
+            tokenUrl: 'https://oauth.platform.intuit.com/oauth2/v1/tokens/bearer',
+            clientId: '',
+            clientSecret: '',
+            scopes: ['com.intuit.quickbooks.accounting'],
+        };
+    }
+    getConfigFields() {
+        return [
+            { name: 'clientId', label: 'QuickBooks App Client ID' },
+            { name: 'clientSecret', label: 'QuickBooks App Client Secret', secret: true },
+        ];
+    }
+    async configure(credentials) {
+        if (this.oauthConfig) {
+            this.oauthConfig.clientId = credentials.clientId || '';
+            this.oauthConfig.clientSecret = credentials.clientSecret || '';
+        }
+    }
+    // Capture realmId from OAuth callback
+    async exchangeCode(code, extras) {
+        if (extras?.realmId)
+            this.realmId = extras.realmId;
+        const tokenData = await super.exchangeCode(code);
+        tokenData.realmId = this.realmId || undefined;
+        this.tokenData = tokenData;
+        return tokenData;
+    }
+    loadCredentials(tokenData) {
+        if (tokenData) {
+            this.tokenData = tokenData;
+            if (tokenData.realmId)
+                this.realmId = tokenData.realmId;
+        }
+    }
+    exportCredentials() {
+        if (!this.tokenData)
+            return null;
+        return { ...this.tokenData, realmId: this.realmId || undefined };
+    }
+    isConnected() {
+        return !!this.tokenData?.access_token && !!this.realmId;
+    }
+    disconnect() {
+        this.realmId = null;
+        this.tokenData = null;
+    }
+    qbBaseUrl() {
+        if (!this.realmId)
+            throw new Error('QuickBooks realmId not set -- reconnect the integration');
+        return `https://quickbooks.api.intuit.com/v3/company/${this.realmId}`;
+    }
+    // QuickBooks requires Accept: application/json
+    async apiRequest(url, options = {}) {
+        const token = await this.getAccessToken();
+        const headers = {
+            'Authorization': `Bearer ${token}`,
+            'Accept': 'application/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) {
+                await this.refreshAccessToken();
+                headers['Authorization'] = `Bearer ${this.tokenData.access_token}`;
+                resp = await fetch(url, { ...options, headers, signal: controller.signal });
+            }
+            return resp;
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    async testConnection() {
+        const start = Date.now();
+        try {
+            const query = encodeURIComponent("select * from Account where AccountType = 'Bank' maxresults 1");
+            const resp = await this.apiRequest(`${this.qbBaseUrl()}/query?query=${query}`);
+            if (!resp.ok)
+                return { success: false, message: `QuickBooks API returned ${resp.status}` };
+            return { success: true, message: `QuickBooks connected (realm: ${this.realmId})`, latencyMs: Date.now() - start };
+        }
+        catch (err) {
+            return { success: false, message: `QuickBooks test failed: ${err instanceof Error ? err.message : String(err)}` };
+        }
+    }
+    async listInvoices() {
+        const query = encodeURIComponent('select * from Invoice orderby TxnDate desc maxresults 20');
+        const resp = await this.apiRequest(`${this.qbBaseUrl()}/query?query=${query}`);
+        if (!resp.ok)
+            throw new Error(`QuickBooks list invoices failed: ${resp.status}`);
+        const data = (await resp.json());
+        return (data.QueryResponse?.Invoice || []).map(inv => ({
+            id: inv.Id, docNumber: inv.DocNumber || '', customerName: inv.CustomerRef?.name || '',
+            totalAmount: inv.TotalAmt || 0, balance: inv.Balance || 0,
+            dueDate: inv.DueDate || '', txnDate: inv.TxnDate || '',
+            status: (inv.Balance || 0) === 0 ? 'Paid' : 'Open',
+        }));
+    }
+    async listCustomers() {
+        const query = encodeURIComponent('select * from Customer maxresults 20');
+        const resp = await this.apiRequest(`${this.qbBaseUrl()}/query?query=${query}`);
+        if (!resp.ok)
+            throw new Error(`QuickBooks list customers failed: ${resp.status}`);
+        const data = (await resp.json());
+        return (data.QueryResponse?.Customer || []).map(c => ({
+            id: c.Id, displayName: c.DisplayName || '', companyName: c.CompanyName || '',
+            email: c.PrimaryEmailAddr?.Address || '', phone: c.PrimaryPhone?.FreeFormNumber || '',
+            balance: c.Balance || 0,
+        }));
+    }
+    async getBalance() {
+        const query = encodeURIComponent("select * from Account where AccountType = 'Bank'");
+        const resp = await this.apiRequest(`${this.qbBaseUrl()}/query?query=${query}`);
+        if (!resp.ok)
+            throw new Error(`QuickBooks get balance failed: ${resp.status}`);
+        const data = (await resp.json());
+        return (data.QueryResponse?.Account || []).map(a => ({
+            id: a.Id, name: a.Name || '', currentBalance: a.CurrentBalance || 0,
+            accountType: a.AccountSubType || a.AccountType || '',
+        }));
+    }
+    getActions() {
+        return [
+            { name: 'listInvoices', description: 'List recent QuickBooks invoices.', parameters: {}, requiredParams: [] },
+            { name: 'listCustomers', description: 'List QuickBooks customers.', parameters: {}, requiredParams: [] },
+            { name: 'getBalance', description: 'Get bank account balances from QuickBooks.', parameters: {}, requiredParams: [] },
+        ];
+    }
+    async executeAction(actionName, params) {
+        try {
+            switch (actionName) {
+                case 'listInvoices': {
+                    const invoices = await this.listInvoices();
+                    if (invoices.length === 0)
+                        return { success: true, output: 'No invoices found.' };
+                    const formatted = invoices.map((inv, i) => `${i + 1}. #${inv.docNumber || inv.id} -- ${inv.customerName || 'N/A'}\n   Total: $${inv.totalAmount}  |  Balance: $${inv.balance}  |  ${inv.status}\n   Date: ${inv.txnDate}  |  Due: ${inv.dueDate || 'N/A'}`).join('\n\n');
+                    return { success: true, output: `${invoices.length} invoices:\n\n${formatted}` };
+                }
+                case 'listCustomers': {
+                    const customers = await this.listCustomers();
+                    if (customers.length === 0)
+                        return { success: true, output: 'No customers found.' };
+                    const formatted = customers.map((c, i) => `${i + 1}. ${c.displayName}${c.companyName ? ' (' + c.companyName + ')' : ''}\n   Email: ${c.email || 'N/A'}  |  Phone: ${c.phone || 'N/A'}\n   Balance: $${c.balance}  |  ID: ${c.id}`).join('\n\n');
+                    return { success: true, output: `${customers.length} customers:\n\n${formatted}` };
+                }
+                case 'getBalance': {
+                    const accounts = await this.getBalance();
+                    if (accounts.length === 0)
+                        return { success: true, output: 'No bank accounts found.' };
+                    const formatted = accounts.map((a, i) => `${i + 1}. ${a.name} (${a.accountType})\n   Balance: $${a.currentBalance.toFixed(2)}  |  ID: ${a.id}`).join('\n\n');
+                    const total = accounts.reduce((sum, a) => sum + a.currentBalance, 0);
+                    return { success: true, output: `${accounts.length} bank accounts:\n\n${formatted}\n\nTotal: $${total.toFixed(2)}` };
+                }
+                default:
+                    return { success: false, output: `Unknown QuickBooks action: ${actionName}` };
+            }
+        }
+        catch (err) {
+            return { success: false, output: `QuickBooks error: ${err instanceof Error ? err.message : String(err)}` };
+        }
+    }
+}

package/src/integrations/providers/SlackProvider.js

@@ -0,0 +1,174 @@
+/**
+ * Slack Provider -- Slack OAuth v2 + Web API
+ * Actions: listChannels, sendMessage, readMessages
+ */
+import { BaseProvider } from './BaseProvider.js';
+export class SlackProvider extends BaseProvider {
+    constructor() {
+        super('slack', 'Slack', 'oauth2');
+        this.oauthConfig = {
+            authUrl: 'https://slack.com/oauth/v2/authorize',
+            tokenUrl: 'https://slack.com/api/oauth.v2.access',
+            clientId: '',
+            clientSecret: '',
+            scopes: ['channels:read', 'channels:history', 'chat:write', 'users:read', 'files:write'],
+        };
+    }
+    getConfigFields() {
+        return [
+            { name: 'clientId', label: 'Slack App Client ID' },
+            { name: 'clientSecret', label: 'Slack App Client Secret', secret: true },
+        ];
+    }
+    async configure(credentials) {
+        if (this.oauthConfig) {
+            this.oauthConfig.clientId = credentials.clientId || '';
+            this.oauthConfig.clientSecret = credentials.clientSecret || '';
+        }
+    }
+    // Slack returns { ok, access_token } in JSON body (non-standard OAuth)
+    async exchangeCode(code) {
+        if (!this.oauthConfig)
+            throw new Error('Slack 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' },
+            body: body.toString(),
+        });
+        if (!resp.ok)
+            throw new Error(`Slack token exchange failed (${resp.status})`);
+        const data = (await resp.json());
+        if (!data.ok)
+            throw new Error(`Slack token exchange error: ${data.error || 'unknown'}`);
+        const tokenData = {
+            access_token: data.access_token,
+            token_type: 'bearer',
+            scope: data.scope,
+            expires_at: null, // Slack bot tokens don't expire
+        };
+        this.tokenData = tokenData;
+        return tokenData;
+    }
+    // Slack bot tokens don't expire -- no refresh needed
+    async refreshAccessToken() {
+        if (this.tokenData?.access_token)
+            return this.tokenData;
+        throw new Error('Slack token missing. Please reconnect.');
+    }
+    async testConnection() {
+        const start = Date.now();
+        try {
+            const resp = await this.apiRequest('https://slack.com/api/auth.test');
+            if (!resp.ok)
+                return { success: false, message: `Slack API returned ${resp.status}` };
+            const data = (await resp.json());
+            if (!data.ok)
+                return { success: false, message: `Slack error: ${data.error}` };
+            return { success: true, message: `Connected as ${data.user} in ${data.team}`, latencyMs: Date.now() - start };
+        }
+        catch (err) {
+            return { success: false, message: `Slack test failed: ${err instanceof Error ? err.message : String(err)}` };
+        }
+    }
+    // ── Slack API ─────────────────────────────────────────────────────────
+    async listChannels() {
+        const resp = await this.apiRequest('https://slack.com/api/conversations.list');
+        if (!resp.ok)
+            throw new Error(`Slack channels list failed: ${resp.status}`);
+        const data = (await resp.json());
+        if (!data.ok)
+            throw new Error(`Slack API error: ${data.error}`);
+        return (data.channels || []).map(c => ({
+            id: c.id,
+            name: c.name,
+            num_members: c.num_members || 0,
+            topic: c.topic?.value,
+        }));
+    }
+    async sendMessage(channel, text) {
+        const resp = await this.apiRequest('https://slack.com/api/chat.postMessage', {
+            method: 'POST',
+            body: JSON.stringify({ channel, text }),
+        });
+        if (!resp.ok)
+            throw new Error(`Slack send failed: ${resp.status}`);
+        const data = (await resp.json());
+        if (!data.ok)
+            throw new Error(`Slack API error: ${data.error}`);
+        return data;
+    }
+    async readMessages(channel, count = 10) {
+        const params = new URLSearchParams({ channel, limit: String(Math.min(count, 100)) });
+        const resp = await this.apiRequest(`https://slack.com/api/conversations.history?${params}`);
+        if (!resp.ok)
+            throw new Error(`Slack history failed: ${resp.status}`);
+        const data = (await resp.json());
+        if (!data.ok)
+            throw new Error(`Slack API error: ${data.error}`);
+        return data.messages || [];
+    }
+    // ── Action interface ──────────────────────────────────────────────────
+    getActions() {
+        return [
+            {
+                name: 'listChannels',
+                description: 'List all channels in the connected Slack workspace.',
+                parameters: {},
+                requiredParams: [],
+            },
+            {
+                name: 'sendMessage',
+                description: 'Send a message to a Slack channel.',
+                parameters: {
+                    channel: { type: 'string', description: 'Channel ID or name (e.g. C01234567 or #general)' },
+                    text: { type: 'string', description: 'Message text to send' },
+                },
+                requiredParams: ['channel', 'text'],
+            },
+            {
+                name: 'readMessages',
+                description: 'Read recent messages from a Slack channel.',
+                parameters: {
+                    channel: { type: 'string', description: 'Channel ID to read from' },
+                    count: { type: 'number', description: 'Number of messages to fetch (default 10, max 100)' },
+                },
+                requiredParams: ['channel'],
+            },
+        ];
+    }
+    async executeAction(actionName, params) {
+        try {
+            switch (actionName) {
+                case 'listChannels': {
+                    const channels = await this.listChannels();
+                    if (channels.length === 0)
+                        return { success: true, output: 'No channels found.' };
+                    const formatted = channels.map((c, i) => `${i + 1}. #${c.name} (ID: ${c.id}) -- ${c.num_members} members${c.topic ? ` -- ${c.topic}` : ''}`).join('\n');
+                    return { success: true, output: `${channels.length} channels:\n\n${formatted}` };
+                }
+                case 'sendMessage': {
+                    const result = await this.sendMessage(params.channel, params.text);
+                    return { success: true, output: `Message sent to ${params.channel} (ts: ${result.ts})` };
+                }
+                case 'readMessages': {
+                    const messages = await this.readMessages(params.channel, params.count || 10);
+                    if (messages.length === 0)
+                        return { success: true, output: 'No messages found.' };
+                    const formatted = messages.map((m, i) => `${i + 1}. [${new Date(parseFloat(m.ts) * 1000).toISOString()}] ${m.user || 'bot'}: ${m.text || ''}`).join('\n\n');
+                    return { success: true, output: `${messages.length} messages:\n\n${formatted}` };
+                }
+                default:
+                    return { success: false, output: `Unknown Slack action: ${actionName}` };
+            }
+        }
+        catch (err) {
+            return { success: false, output: `Slack error: ${err instanceof Error ? err.message : String(err)}` };
+        }
+    }
+}

package/src/integrations/providers/StripeProvider.js

@@ -0,0 +1,206 @@
+/**
+ * Stripe Provider -- API key-based (no OAuth)
+ * Actions: listPayments, getBalance, listCustomers, createPaymentLink,
+ *          searchCustomer, listSubscriptions, getSubscription,
+ *          cancelSubscription, updateSubscription
+ */
+import { BaseProvider } from './BaseProvider.js';
+export class StripeProvider extends BaseProvider {
+    apiKey = '';
+    constructor() {
+        super('stripe', 'Stripe', 'api_key');
+    }
+    getConfigFields() {
+        return [{ name: 'apiKey', label: 'Stripe Secret Key (sk_...)', secret: true }];
+    }
+    async configure(credentials) {
+        this.apiKey = credentials.apiKey || '';
+        this.tokenData = { access_token: this.apiKey, type: 'api_key' };
+    }
+    loadCredentials(tokenData) {
+        if (tokenData?.access_token) {
+            this.apiKey = tokenData.access_token;
+            this.tokenData = tokenData;
+        }
+    }
+    exportCredentials() {
+        if (!this.isConnected())
+            return null;
+        return { access_token: this.apiKey, type: 'api_key' };
+    }
+    isConnected() {
+        return !!this.apiKey && this.apiKey.startsWith('sk_');
+    }
+    disconnect() {
+        this.apiKey = '';
+        this.tokenData = null;
+    }
+    async apiRequest(url, options = {}) {
+        const headers = {
+            'Authorization': `Bearer ${this.apiKey}`,
+            'Content-Type': 'application/x-www-form-urlencoded',
+            ...(options.headers || {}),
+        };
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), 30000);
+        try {
+            return await fetch(url, { ...options, headers, signal: controller.signal });
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    async testConnection() {
+        const start = Date.now();
+        try {
+            const resp = await this.apiRequest('https://api.stripe.com/v1/balance');
+            if (!resp.ok)
+                return { success: false, message: `Stripe API returned ${resp.status}` };
+            return { success: true, message: 'Stripe balance retrieved successfully', latencyMs: Date.now() - start };
+        }
+        catch (err) {
+            return { success: false, message: `Stripe test failed: ${err instanceof Error ? err.message : String(err)}` };
+        }
+    }
+    // ── Stripe API ────────────────────────────────────────────────────────
+    async listPayments(limit = 20) {
+        const resp = await this.apiRequest(`https://api.stripe.com/v1/charges?limit=${limit}`);
+        if (!resp.ok)
+            throw new Error(`Stripe list charges failed: ${resp.status}`);
+        const data = (await resp.json());
+        return (data.data || []).map(c => ({
+            id: c.id, amount: (c.amount / 100).toFixed(2), currency: c.currency.toUpperCase(),
+            status: c.status, description: c.description || '', customer: c.customer || '',
+            created: new Date(c.created * 1000).toISOString(),
+        }));
+    }
+    async getBalance() {
+        const resp = await this.apiRequest('https://api.stripe.com/v1/balance');
+        if (!resp.ok)
+            throw new Error(`Stripe balance failed: ${resp.status}`);
+        const data = (await resp.json());
+        return {
+            available: data.available.map(b => `${(b.amount / 100).toFixed(2)} ${b.currency.toUpperCase()}`),
+            pending: data.pending.map(b => `${(b.amount / 100).toFixed(2)} ${b.currency.toUpperCase()}`),
+        };
+    }
+    async listCustomers(limit = 20) {
+        const resp = await this.apiRequest(`https://api.stripe.com/v1/customers?limit=${limit}`);
+        if (!resp.ok)
+            throw new Error(`Stripe list customers failed: ${resp.status}`);
+        const data = (await resp.json());
+        return (data.data || []).map(c => ({
+            id: c.id, email: c.email || '', name: c.name || '',
+            created: new Date(c.created * 1000).toISOString(),
+        }));
+    }
+    async createPaymentLink(name, amountCents, currency = 'usd') {
+        const prodResp = await this.apiRequest('https://api.stripe.com/v1/products', {
+            method: 'POST', body: new URLSearchParams({ name }).toString(),
+        });
+        if (!prodResp.ok)
+            throw new Error(`Stripe create product failed: ${prodResp.status}`);
+        const product = (await prodResp.json());
+        const priceResp = await this.apiRequest('https://api.stripe.com/v1/prices', {
+            method: 'POST',
+            body: new URLSearchParams({ product: product.id, unit_amount: String(amountCents), currency }).toString(),
+        });
+        if (!priceResp.ok)
+            throw new Error(`Stripe create price failed: ${priceResp.status}`);
+        const price = (await priceResp.json());
+        const linkResp = await this.apiRequest('https://api.stripe.com/v1/payment_links', {
+            method: 'POST',
+            body: new URLSearchParams({ 'line_items[0][price]': price.id, 'line_items[0][quantity]': '1' }).toString(),
+        });
+        if (!linkResp.ok)
+            throw new Error(`Stripe create link failed: ${linkResp.status}`);
+        return (await linkResp.json());
+    }
+    async searchCustomer(email) {
+        const resp = await this.apiRequest(`https://api.stripe.com/v1/customers/search?query=email:"${encodeURIComponent(email)}"`);
+        if (!resp.ok)
+            throw new Error(`Stripe search customer failed: ${resp.status}`);
+        const data = (await resp.json());
+        return data.data || [];
+    }
+    async listSubscriptions(limit = 20, status) {
+        let url = `https://api.stripe.com/v1/subscriptions?limit=${limit}`;
+        if (status)
+            url += `&status=${status}`;
+        const resp = await this.apiRequest(url);
+        if (!resp.ok)
+            throw new Error(`Stripe list subscriptions failed: ${resp.status}`);
+        const data = (await resp.json());
+        return (data.data || []).map(s => ({
+            id: s.id, status: s.status,
+            customer: typeof s.customer === 'string' ? s.customer : (s.customer?.email || ''),
+            plan: s.items?.data?.[0]?.price?.nickname || s.items?.data?.[0]?.price?.id || '',
+            amount: ((s.items?.data?.[0]?.price?.unit_amount || 0) / 100).toFixed(2),
+            currency: (s.items?.data?.[0]?.price?.currency || 'usd').toUpperCase(),
+            interval: s.items?.data?.[0]?.price?.recurring?.interval || '',
+            currentPeriodEnd: new Date(s.current_period_end * 1000).toISOString(),
+            cancelAtPeriodEnd: s.cancel_at_period_end,
+            created: new Date(s.created * 1000).toISOString(),
+        }));
+    }
+    // ── Action interface ──────────────────────────────────────────────────
+    getActions() {
+        return [
+            { name: 'listPayments', description: 'List recent Stripe payments/charges.', parameters: { count: { type: 'number', description: 'Number of payments (default 20)' } }, requiredParams: [] },
+            { name: 'getBalance', description: 'Get the current Stripe account balance.', parameters: {}, requiredParams: [] },
+            { name: 'listCustomers', description: 'List Stripe customers.', parameters: { count: { type: 'number', description: 'Number of customers (default 20)' } }, requiredParams: [] },
+            { name: 'createPaymentLink', description: 'Create a Stripe Payment Link.', parameters: { name: { type: 'string', description: 'Product/service name' }, amount: { type: 'number', description: 'Price in dollars (e.g. 29.99)' }, currency: { type: 'string', description: 'Currency code (default "usd")' } }, requiredParams: ['name', 'amount'] },
+            { name: 'searchCustomer', description: 'Search for a Stripe customer by email.', parameters: { email: { type: 'string', description: 'Customer email to search for' } }, requiredParams: ['email'] },
+            { name: 'listSubscriptions', description: 'List Stripe subscriptions.', parameters: { count: { type: 'number', description: 'Number of subscriptions (default 20)' }, status: { type: 'string', description: 'Filter by status: active, past_due, canceled, all' } }, requiredParams: [] },
+        ];
+    }
+    async executeAction(actionName, params) {
+        try {
+            switch (actionName) {
+                case 'listPayments': {
+                    const payments = await this.listPayments(params.count || 20);
+                    if (payments.length === 0)
+                        return { success: true, output: 'No payments found.' };
+                    const formatted = payments.map((p, i) => `${i + 1}. $${p.amount} ${p.currency} -- ${p.status} -- ${p.description || '(no desc)'}\n   Customer: ${p.customer || 'N/A'}  |  ${p.created}\n   ID: ${p.id}`).join('\n\n');
+                    return { success: true, output: `${payments.length} payments:\n\n${formatted}` };
+                }
+                case 'getBalance': {
+                    const bal = await this.getBalance();
+                    return { success: true, output: `Stripe Balance:\n  Available: ${bal.available.join(', ') || '$0.00'}\n  Pending: ${bal.pending.join(', ') || '$0.00'}` };
+                }
+                case 'listCustomers': {
+                    const customers = await this.listCustomers(params.count || 20);
+                    if (customers.length === 0)
+                        return { success: true, output: 'No customers found.' };
+                    const formatted = customers.map((c, i) => `${i + 1}. ${c.name || '(no name)'} -- ${c.email || '(no email)'}\n   ID: ${c.id}  |  Created: ${c.created}`).join('\n');
+                    return { success: true, output: `${customers.length} customers:\n${formatted}` };
+                }
+                case 'createPaymentLink': {
+                    const amountCents = Math.round((params.amount || 0) * 100);
+                    const result = await this.createPaymentLink(params.name, amountCents, params.currency || 'usd');
+                    return { success: true, output: `Payment link created: ${result.url}\nPrice: $${(amountCents / 100).toFixed(2)} ${(params.currency || 'usd').toUpperCase()}` };
+                }
+                case 'searchCustomer': {
+                    const results = await this.searchCustomer(params.email);
+                    if (results.length === 0)
+                        return { success: true, output: `No customer found with email: ${params.email}` };
+                    const formatted = results.map(c => `Customer: ${c.name || '(no name)'} -- ${c.email}\nID: ${c.id}`).join('\n\n');
+                    return { success: true, output: formatted };
+                }
+                case 'listSubscriptions': {
+                    const status = params.status === 'all' ? null : params.status || null;
+                    const subs = await this.listSubscriptions(params.count || 20, status);
+                    if (subs.length === 0)
+                        return { success: true, output: 'No subscriptions found.' };
+                    const formatted = subs.map((s, i) => `${i + 1}. ${s.customer || 'Unknown'} -- ${s.status.toUpperCase()}\n   $${s.amount} ${s.currency}/${s.interval} -- ${s.plan}\n   ID: ${s.id}  |  Ends: ${s.currentPeriodEnd}${s.cancelAtPeriodEnd ? '  (cancels at period end)' : ''}`).join('\n\n');
+                    return { success: true, output: `${subs.length} subscriptions:\n\n${formatted}` };
+                }
+                default:
+                    return { success: false, output: `Unknown Stripe action: ${actionName}` };
+            }
+        }
+        catch (err) {
+            return { success: false, output: `Stripe error: ${err instanceof Error ? err.message : String(err)}` };
+        }
+    }
+}