@praveencs/agent 0.9.30 → 0.10.0

package/agent-skills/plugins/slack/skills/slack-manager.md

@@ -0,0 +1,15 @@
+# Slack Manager
+
+## Description
+This skill enables you to send messages, manage channels, search workspace history, and upload files to Slack.
+
+## Instructions
+1. When asked to send a Slack message, use the `slack` tool with `action: "send_message"`. You need the `channel` (use a channel ID like `C01ABCDEF` or a channel name like `#general`) and the `text`.
+2. For rich messages, use Slack's **mrkdwn** format: `*bold*`, `_italic_`, `~strikethrough~`, `` `code` ``, `> quote`. You can also pass `blocks` for Block Kit layouts.
+3. To find a channel ID, first call `action: "list_channels"` and look for the channel name in the results.
+4. To search message history, use `action: "search"` with a `query`. Slack search supports operators like `from:@user`, `in:#channel`, `before:2024-01-01`, `has:link`.
+5. To reply in a thread, use `action: "send_reply"` and provide the `thread_ts` from the parent message.
+6. If the tool returns an authentication error, inform the user they need to export `SLACK_BOT_TOKEN`. They can create a Slack App at https://api.slack.com/apps.
+
+## Input Variables
+{{input}}

package/agent-skills/plugins/slack/tools/slack.js

@@ -0,0 +1,168 @@
+/**
+ * Slack automation tool.
+ * Provides messaging, channel management, and search via the Slack Web API.
+ */
+export async function execute(params) {
+    const { action, ...args } = params;
+    const token = process.env.SLACK_BOT_TOKEN;
+
+    if (!token) {
+        throw new Error('SLACK_BOT_TOKEN environment variable is not set. Create a Slack App at https://api.slack.com/apps and add a Bot Token.');
+    }
+
+    const headers = {
+        'Content-Type': 'application/json; charset=utf-8',
+        'Authorization': `Bearer ${token}`
+    };
+
+    async function slackAPI(method, body = null) {
+        const url = `https://slack.com/api/${method}`;
+        const options = { method: 'POST', headers };
+        if (body) options.body = JSON.stringify(body);
+
+        const res = await fetch(url, options);
+        const data = await res.json();
+
+        if (!data.ok) {
+            throw new Error(`Slack API Error (${method}): ${data.error}`);
+        }
+        return data;
+    }
+
+    try {
+        switch (action) {
+            // --- MESSAGING ---
+            case 'send_message':
+                return await slackAPI('chat.postMessage', {
+                    channel: args.channel,
+                    text: args.text,
+                    blocks: args.blocks || undefined
+                });
+
+            case 'send_reply':
+                return await slackAPI('chat.postMessage', {
+                    channel: args.channel,
+                    text: args.text,
+                    thread_ts: args.thread_ts
+                });
+
+            case 'update_message':
+                return await slackAPI('chat.update', {
+                    channel: args.channel,
+                    ts: args.ts,
+                    text: args.text
+                });
+
+            case 'delete_message':
+                return await slackAPI('chat.delete', {
+                    channel: args.channel,
+                    ts: args.ts
+                });
+
+            // --- CHANNELS ---
+            case 'list_channels':
+                return await slackAPI('conversations.list', {
+                    types: args.types || 'public_channel,private_channel',
+                    limit: args.limit || 100
+                });
+
+            case 'create_channel':
+                return await slackAPI('conversations.create', {
+                    name: args.name,
+                    is_private: args.is_private || false
+                });
+
+            case 'set_topic':
+                return await slackAPI('conversations.setTopic', {
+                    channel: args.channel,
+                    topic: args.topic
+                });
+
+            case 'invite_to_channel':
+                return await slackAPI('conversations.invite', {
+                    channel: args.channel,
+                    users: args.users // comma-separated user IDs
+                });
+
+            // --- SEARCH ---
+            case 'search':
+                return await slackAPI('search.messages', {
+                    query: args.query,
+                    count: args.count || 20,
+                    sort: args.sort || 'timestamp'
+                });
+
+            // --- FILES ---
+            case 'upload_file':
+                // Use the v2 file upload
+                return await slackAPI('files.uploadV2', {
+                    channel_id: args.channel,
+                    content: args.content,
+                    filename: args.filename,
+                    title: args.title || args.filename
+                });
+
+            // --- USERS ---
+            case 'list_users':
+                return await slackAPI('users.list', {
+                    limit: args.limit || 100
+                });
+
+            case 'user_info':
+                return await slackAPI('users.info', {
+                    user: args.user
+                });
+
+            // --- REACTIONS ---
+            case 'add_reaction':
+                return await slackAPI('reactions.add', {
+                    channel: args.channel,
+                    timestamp: args.ts,
+                    name: args.emoji
+                });
+
+            default:
+                throw new Error(`Unknown action: ${action}`);
+        }
+    } catch (err) {
+        return { error: err.message, stack: err.stack };
+    }
+}
+
+export const definition = {
+    name: 'slack',
+    description: 'Interact with Slack to send messages, manage channels, search history, and upload files. Requires SLACK_BOT_TOKEN.',
+    parameters: {
+        type: 'object',
+        required: ['action'],
+        properties: {
+            action: {
+                type: 'string',
+                description: 'The Slack operation to perform',
+                enum: [
+                    'send_message', 'send_reply', 'update_message', 'delete_message',
+                    'list_channels', 'create_channel', 'set_topic', 'invite_to_channel',
+                    'search', 'upload_file',
+                    'list_users', 'user_info',
+                    'add_reaction'
+                ]
+            },
+            channel: { type: 'string', description: 'Channel ID or name (e.g., "#general" or "C01ABCDEF")' },
+            text: { type: 'string', description: 'Message text (supports Slack mrkdwn formatting)' },
+            thread_ts: { type: 'string', description: 'Thread timestamp to reply to' },
+            ts: { type: 'string', description: 'Message timestamp (for update/delete/reaction)' },
+            name: { type: 'string', description: 'Channel name (for create_channel)' },
+            is_private: { type: 'boolean', description: 'Whether to create a private channel' },
+            topic: { type: 'string', description: 'Channel topic text' },
+            users: { type: 'string', description: 'Comma-separated user IDs (for invite)' },
+            query: { type: 'string', description: 'Search query string' },
+            content: { type: 'string', description: 'File content to upload' },
+            filename: { type: 'string', description: 'Filename for upload' },
+            title: { type: 'string', description: 'Title for uploaded file' },
+            user: { type: 'string', description: 'User ID for user_info' },
+            emoji: { type: 'string', description: 'Emoji name without colons (e.g., "thumbsup")' },
+            blocks: { type: 'array', description: 'Slack Block Kit blocks for rich messages' },
+            limit: { type: 'number', description: 'Max results to return' }
+        }
+    }
+};

package/agent-skills/plugins/stripe/plugin.json

@@ -0,0 +1,22 @@
+{
+    "name": "stripe",
+    "version": "1.0.0",
+    "description": "Manage customers, subscriptions, payments, and invoices on Stripe.",
+    "author": "Praveen",
+    "category": "Payments & Business",
+    "tags": [
+        "stripe",
+        "payments",
+        "billing",
+        "subscriptions",
+        "saas"
+    ],
+    "exports": {
+        "tools": [
+            "tools/stripe.js"
+        ],
+        "skills": [
+            "skills/stripe-manager.md"
+        ]
+    }
+}

package/agent-skills/plugins/stripe/skills/stripe-manager.md

@@ -0,0 +1,16 @@
+# Stripe Manager
+
+## Description
+This skill enables you to manage customers, products, subscriptions, checkout sessions, invoices, and refunds on Stripe.
+
+## Instructions
+1. Stripe amounts are always in **cents**. $19.99 = `1999`. Always convert before passing to the tool.
+2. To set up a SaaS billing flow: first `create_product`, then `create_price` (with `interval` for recurring), then `create_checkout` or `create_subscription`.
+3. Customer IDs start with `cus_`, product IDs with `prod_`, price IDs with `price_`, subscription IDs with `sub_`.
+4. For checkout sessions, always provide `success_url` and `cancel_url` — these are where Stripe redirects after payment.
+5. To issue a partial refund, use `create_refund` with both `payment_intent` and `amount` (in cents).
+6. Use `get_balance` to check the current Stripe account balance.
+7. If the tool returns an authentication error, the user needs to export `STRIPE_SECRET_KEY` from https://dashboard.stripe.com/apikeys. Use **test mode keys** (`sk_test_...`) for development.
+
+## Input Variables
+{{input}}

package/agent-skills/plugins/stripe/tools/stripe.js

@@ -0,0 +1,174 @@
+/**
+ * Stripe automation tool.
+ * Provides customer, subscription, payment, and invoice management via the Stripe REST API.
+ * Uses form-encoded requests as required by Stripe's API.
+ */
+export async function execute(params) {
+    const { action, ...args } = params;
+    const key = process.env.STRIPE_SECRET_KEY;
+
+    if (!key) {
+        throw new Error('STRIPE_SECRET_KEY environment variable is not set. Find it at https://dashboard.stripe.com/apikeys');
+    }
+
+    const headers = {
+        'Authorization': `Bearer ${key}`,
+        'Content-Type': 'application/x-www-form-urlencoded'
+    };
+
+    /** Convert a flat object to URL-encoded form data (supports nested via bracket notation) */
+    function toForm(obj, prefix = '') {
+        const parts = [];
+        for (const [key, val] of Object.entries(obj)) {
+            if (val === undefined || val === null) continue;
+            const fullKey = prefix ? `${prefix}[${key}]` : key;
+            if (typeof val === 'object' && !Array.isArray(val)) {
+                parts.push(toForm(val, fullKey));
+            } else {
+                parts.push(`${encodeURIComponent(fullKey)}=${encodeURIComponent(val)}`);
+            }
+        }
+        return parts.join('&');
+    }
+
+    async function stripeFetch(method, endpoint, body = null) {
+        const url = `https://api.stripe.com/v1${endpoint}`;
+        const options = { method, headers };
+        if (body) options.body = toForm(body);
+
+        const res = await fetch(url, options);
+        const data = await res.json();
+
+        if (!res.ok) {
+            throw new Error(`Stripe API Error: ${data.error?.message || JSON.stringify(data)}`);
+        }
+        return data;
+    }
+
+    try {
+        switch (action) {
+            // --- CUSTOMERS ---
+            case 'create_customer':
+                return await stripeFetch('POST', '/customers', {
+                    email: args.email,
+                    name: args.name,
+                    description: args.description,
+                    metadata: args.metadata
+                });
+
+            case 'list_customers':
+                return await stripeFetch('GET', `/customers?limit=${args.limit || 10}`);
+
+            case 'get_customer':
+                return await stripeFetch('GET', `/customers/${args.customer_id}`);
+
+            case 'update_customer':
+                return await stripeFetch('POST', `/customers/${args.customer_id}`, args.data || {});
+
+            case 'delete_customer':
+                return await stripeFetch('DELETE', `/customers/${args.customer_id}`);
+
+            // --- PRODUCTS & PRICES ---
+            case 'create_product':
+                return await stripeFetch('POST', '/products', {
+                    name: args.name,
+                    description: args.description
+                });
+
+            case 'create_price':
+                return await stripeFetch('POST', '/prices', {
+                    product: args.product_id,
+                    unit_amount: args.amount,      // in cents
+                    currency: args.currency || 'usd',
+                    recurring: args.interval ? { interval: args.interval } : undefined
+                });
+
+            case 'list_products':
+                return await stripeFetch('GET', `/products?limit=${args.limit || 10}&active=true`);
+
+            // --- SUBSCRIPTIONS ---
+            case 'create_subscription':
+                return await stripeFetch('POST', '/subscriptions', {
+                    customer: args.customer_id,
+                    'items[0][price]': args.price_id
+                });
+
+            case 'list_subscriptions':
+                return await stripeFetch('GET', `/subscriptions?customer=${args.customer_id}&limit=${args.limit || 10}`);
+
+            case 'cancel_subscription':
+                return await stripeFetch('DELETE', `/subscriptions/${args.subscription_id}`);
+
+            // --- CHECKOUT ---
+            case 'create_checkout':
+                return await stripeFetch('POST', '/checkout/sessions', {
+                    mode: args.mode || 'payment',
+                    success_url: args.success_url,
+                    cancel_url: args.cancel_url,
+                    'line_items[0][price]': args.price_id,
+                    'line_items[0][quantity]': args.quantity || 1,
+                    customer_email: args.email
+                });
+
+            // --- INVOICES ---
+            case 'list_invoices':
+                return await stripeFetch('GET', `/invoices?customer=${args.customer_id || ''}&limit=${args.limit || 10}`);
+
+            // --- REFUNDS ---
+            case 'create_refund':
+                return await stripeFetch('POST', '/refunds', {
+                    payment_intent: args.payment_intent,
+                    amount: args.amount    // partial refund in cents
+                });
+
+            // --- BALANCE ---
+            case 'get_balance':
+                return await stripeFetch('GET', '/balance');
+
+            default:
+                throw new Error(`Unknown action: ${action}`);
+        }
+    } catch (err) {
+        return { error: err.message, stack: err.stack };
+    }
+}
+
+export const definition = {
+    name: 'stripe',
+    description: 'Manage Stripe customers, products, subscriptions, checkout sessions, invoices, and refunds. Requires STRIPE_SECRET_KEY.',
+    parameters: {
+        type: 'object',
+        required: ['action'],
+        properties: {
+            action: {
+                type: 'string',
+                description: 'The Stripe operation to perform',
+                enum: [
+                    'create_customer', 'list_customers', 'get_customer', 'update_customer', 'delete_customer',
+                    'create_product', 'create_price', 'list_products',
+                    'create_subscription', 'list_subscriptions', 'cancel_subscription',
+                    'create_checkout',
+                    'list_invoices', 'create_refund', 'get_balance'
+                ]
+            },
+            customer_id: { type: 'string', description: 'Stripe customer ID (cus_xxx)' },
+            email: { type: 'string', description: 'Customer email' },
+            name: { type: 'string', description: 'Customer or product name' },
+            description: { type: 'string', description: 'Description text' },
+            product_id: { type: 'string', description: 'Stripe product ID (prod_xxx)' },
+            price_id: { type: 'string', description: 'Stripe price ID (price_xxx)' },
+            amount: { type: 'number', description: 'Amount in cents (e.g., 1999 = $19.99)' },
+            currency: { type: 'string', description: 'Currency code (default: usd)' },
+            interval: { type: 'string', description: 'Billing interval: month, year, week, day' },
+            subscription_id: { type: 'string', description: 'Stripe subscription ID (sub_xxx)' },
+            mode: { type: 'string', description: 'Checkout mode: payment, subscription, setup' },
+            success_url: { type: 'string', description: 'URL to redirect after successful checkout' },
+            cancel_url: { type: 'string', description: 'URL to redirect after cancelled checkout' },
+            quantity: { type: 'number', description: 'Quantity for checkout line item' },
+            payment_intent: { type: 'string', description: 'Payment intent ID for refunds (pi_xxx)' },
+            data: { type: 'object', description: 'Arbitrary update data for customer updates' },
+            metadata: { type: 'object', description: 'Key-value metadata for Stripe objects' },
+            limit: { type: 'number', description: 'Max results to return' }
+        }
+    }
+};

package/agent-skills/plugins/supabase/plugin.json

@@ -0,0 +1,22 @@
+{
+    "name": "supabase",
+    "version": "1.0.0",
+    "description": "Query Postgres databases, manage auth users, and interact with storage buckets on Supabase.",
+    "author": "Praveen",
+    "category": "Databases & Backend",
+    "tags": [
+        "supabase",
+        "postgres",
+        "database",
+        "auth",
+        "baas"
+    ],
+    "exports": {
+        "tools": [
+            "tools/supabase.js"
+        ],
+        "skills": [
+            "skills/supabase-manager.md"
+        ]
+    }
+}

package/agent-skills/plugins/supabase/skills/supabase-manager.md

@@ -0,0 +1,16 @@
+# Supabase Manager
+
+## Description
+This skill enables you to query Postgres databases, manage auth users, and interact with storage buckets on Supabase.
+
+## Instructions
+1. To query data, use `action: "select"` with `table` and optionally `columns` and `filter`. Filters use PostgREST syntax: `"status=eq.active"`, `"age=gt.18"`, `"name=like.*john*"`.
+2. To insert data, use `action: "insert"` with `table` and `data` (a JSON object matching the table columns).
+3. To update data, use `action: "update"` with `table`, `filter` (to select rows), and `data` (fields to update). **Always include a filter** to avoid updating all rows.
+4. To call a Postgres function, use `action: "rpc"` with `function_name` and `params`.
+5. Auth management (list/create/delete users) requires `SUPABASE_SERVICE_KEY` (the service role key, not the anon key).
+6. PostgREST filter operators: `eq`, `neq`, `gt`, `gte`, `lt`, `lte`, `like`, `ilike`, `in`, `is`, `not`.
+7. If the tool returns an error, ensure `SUPABASE_URL` and `SUPABASE_KEY` are exported. Find them in the Supabase dashboard under Settings > API.
+
+## Input Variables
+{{input}}

package/agent-skills/plugins/supabase/tools/supabase.js

@@ -0,0 +1,153 @@
+/**
+ * Supabase automation tool.
+ * Provides database queries, auth management, and storage via the Supabase REST API.
+ */
+export async function execute(params) {
+    const { action, ...args } = params;
+    const url = process.env.SUPABASE_URL;
+    const key = process.env.SUPABASE_KEY;
+
+    if (!url || !key) {
+        throw new Error('SUPABASE_URL and SUPABASE_KEY environment variables must be set. Find them in your Supabase project settings.');
+    }
+
+    const headers = {
+        'Content-Type': 'application/json',
+        'apikey': key,
+        'Authorization': `Bearer ${key}`
+    };
+
+    async function supaFetch(method, endpoint, body = null, extraHeaders = {}) {
+        const fullUrl = `${url}${endpoint}`;
+        const options = { method, headers: { ...headers, ...extraHeaders } };
+        if (body) options.body = JSON.stringify(body);
+
+        const res = await fetch(fullUrl, options);
+        if (res.status === 204) return { success: true };
+
+        let data;
+        try {
+            data = await res.json();
+        } catch {
+            data = await res.text();
+        }
+
+        if (!res.ok) {
+            throw new Error(`Supabase API Error (${res.status}): ${JSON.stringify(data)}`);
+        }
+        return data;
+    }
+
+    try {
+        switch (action) {
+            // --- DATABASE (PostgREST) ---
+            case 'select':
+                // args.table, args.columns (default "*"), args.filter (PostgREST query string)
+                return await supaFetch('GET',
+                    `/rest/v1/${args.table}?select=${args.columns || '*'}${args.filter ? '&' + args.filter : ''}`,
+                    null,
+                    { 'Range': `0-${(args.limit || 100) - 1}` }
+                );
+
+            case 'insert':
+                return await supaFetch('POST', `/rest/v1/${args.table}`, args.data, {
+                    'Prefer': 'return=representation'
+                });
+
+            case 'update':
+                // args.filter is required, e.g. "id=eq.123"
+                return await supaFetch('PATCH',
+                    `/rest/v1/${args.table}?${args.filter}`,
+                    args.data,
+                    { 'Prefer': 'return=representation' }
+                );
+
+            case 'delete':
+                return await supaFetch('DELETE',
+                    `/rest/v1/${args.table}?${args.filter}`
+                );
+
+            case 'rpc':
+                // Call a Postgres function
+                return await supaFetch('POST', `/rest/v1/rpc/${args.function_name}`, args.params || {});
+
+            // --- AUTH ---
+            case 'list_users':
+                return await supaFetch('GET', '/auth/v1/admin/users', null, {
+                    'Authorization': `Bearer ${process.env.SUPABASE_SERVICE_KEY || key}`
+                });
+
+            case 'create_user':
+                return await supaFetch('POST', '/auth/v1/admin/users', {
+                    email: args.email,
+                    password: args.password,
+                    email_confirm: args.email_confirm !== false
+                }, {
+                    'Authorization': `Bearer ${process.env.SUPABASE_SERVICE_KEY || key}`
+                });
+
+            case 'delete_user':
+                return await supaFetch('DELETE', `/auth/v1/admin/users/${args.user_id}`, null, {
+                    'Authorization': `Bearer ${process.env.SUPABASE_SERVICE_KEY || key}`
+                });
+
+            // --- STORAGE ---
+            case 'list_buckets':
+                return await supaFetch('GET', '/storage/v1/bucket');
+
+            case 'create_bucket':
+                return await supaFetch('POST', '/storage/v1/bucket', {
+                    name: args.bucket_name,
+                    public: args.public || false
+                });
+
+            case 'list_files':
+                return await supaFetch('POST', `/storage/v1/object/list/${args.bucket_name}`, {
+                    prefix: args.prefix || '',
+                    limit: args.limit || 100
+                });
+
+            case 'delete_file':
+                return await supaFetch('DELETE', `/storage/v1/object/${args.bucket_name}/${args.path}`);
+
+            default:
+                throw new Error(`Unknown action: ${action}`);
+        }
+    } catch (err) {
+        return { error: err.message, stack: err.stack };
+    }
+}
+
+export const definition = {
+    name: 'supabase',
+    description: 'Interact with Supabase for database queries (PostgREST), auth user management, and storage. Requires SUPABASE_URL and SUPABASE_KEY.',
+    parameters: {
+        type: 'object',
+        required: ['action'],
+        properties: {
+            action: {
+                type: 'string',
+                description: 'The Supabase operation to perform',
+                enum: [
+                    'select', 'insert', 'update', 'delete', 'rpc',
+                    'list_users', 'create_user', 'delete_user',
+                    'list_buckets', 'create_bucket', 'list_files', 'delete_file'
+                ]
+            },
+            table: { type: 'string', description: 'Database table name' },
+            columns: { type: 'string', description: 'Columns to select (default: "*")' },
+            filter: { type: 'string', description: 'PostgREST filter string (e.g., "status=eq.active&age=gt.18")' },
+            data: { type: 'object', description: 'Data object for insert/update' },
+            function_name: { type: 'string', description: 'Postgres function name (for RPC calls)' },
+            params: { type: 'object', description: 'Parameters for RPC function calls' },
+            email: { type: 'string', description: 'Email for user creation' },
+            password: { type: 'string', description: 'Password for user creation' },
+            user_id: { type: 'string', description: 'User UUID (for deletion)' },
+            bucket_name: { type: 'string', description: 'Storage bucket name' },
+            path: { type: 'string', description: 'File path within the bucket' },
+            prefix: { type: 'string', description: 'File prefix filter for listing' },
+            public: { type: 'boolean', description: 'Whether the bucket is public' },
+            limit: { type: 'number', description: 'Max results to return' }
+        }
+    }
+};

package/agent-skills/plugins/telegram/plugin.json

@@ -0,0 +1,21 @@
+{
+    "name": "telegram",
+    "version": "1.0.0",
+    "description": "Send messages, manage groups, and interact with Telegram bots via the Bot API.",
+    "author": "Praveen",
+    "category": "Communication",
+    "tags": [
+        "telegram",
+        "messaging",
+        "bot",
+        "chat"
+    ],
+    "exports": {
+        "tools": [
+            "tools/telegram.js"
+        ],
+        "skills": [
+            "skills/telegram-manager.md"
+        ]
+    }
+}

package/agent-skills/plugins/telegram/skills/telegram-manager.md

@@ -0,0 +1,14 @@
+# Telegram Manager
+
+## Description
+This skill enables you to send messages, photos, documents, polls, and manage groups via Telegram bots.
+
+## Instructions
+1. Messages support **HTML** formatting by default: `<b>bold</b>`, `<i>italic</i>`, `<code>code</code>`, `<a href="url">link</a>`.
+2. Chat IDs can be numeric IDs or `@username` for public groups/channels.
+3. To send a file by URL, use `action: "send_photo"` or `"send_document"` with the URL as the `photo`/`document` value.
+4. Use `action: "get_updates"` to see recent incoming messages to the bot.
+5. Requires `TELEGRAM_BOT_TOKEN` from @BotFather on Telegram.
+
+## Input Variables
+{{input}}