openwriter 0.6.3 → 0.6.5

package/dist/plugins/publish/dist/index.js

@@ -0,0 +1,697 @@
+import { getServerModules, publishFetch } from './helpers.js';
+import { newsletterTools } from './newsletter-tools.js';
+const plugin = {
+    name: '@openwriter/plugin-publish',
+    version: '0.1.0',
+    description: 'OpenWriter Publish — newsletter, custom domains, publishing',
+    category: 'publishing',
+    configSchema: {
+        'api-url': {
+            type: 'string',
+            description: 'Publish API URL',
+            env: 'PUBLISH_API_URL',
+        },
+        'api-key': {
+            type: 'string',
+            required: true,
+            description: 'API key (ow_live_...)',
+            env: 'PUBLISH_API_KEY',
+        },
+    },
+    mcpTools(config) {
+        const baseUrl = config['api-url'] || 'https://publish.openwriter.io';
+        return [
+            {
+                name: 'request_login_code',
+                description: 'Request a 6-digit verification code sent to the given email. First step of authentication — works for both new signups and key recovery.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        email: { type: 'string', description: 'Email address to send the verification code to' },
+                    },
+                    required: ['email'],
+                },
+                handler: async (params) => {
+                    const email = params.email;
+                    const res = await fetch(`${baseUrl}/auth/request-code`, {
+                        method: 'POST',
+                        headers: { 'Content-Type': 'application/json' },
+                        body: JSON.stringify({ email }),
+                    });
+                    if (!res.ok) {
+                        const err = await res.json().catch(() => ({}));
+                        return { error: `Failed to request code: ${err.error || res.statusText}` };
+                    }
+                    const data = await res.json();
+                    return {
+                        success: true,
+                        email: data.email,
+                        expires_in_seconds: data.expires_in_seconds,
+                        message: `Verification code sent to ${data.email}. Ask the user for the 6-digit code from their inbox, then call verify_login.`,
+                    };
+                },
+            },
+            {
+                name: 'verify_login',
+                description: 'Verify a 6-digit code and obtain an API key. Second step of authentication. On success, the API key is automatically saved to plugin config.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        email: { type: 'string', description: 'Email address the code was sent to' },
+                        code: { type: 'string', description: '6-digit verification code from email' },
+                    },
+                    required: ['email', 'code'],
+                },
+                handler: async (params) => {
+                    const email = params.email;
+                    const code = params.code;
+                    const res = await fetch(`${baseUrl}/auth/verify-code`, {
+                        method: 'POST',
+                        headers: { 'Content-Type': 'application/json' },
+                        body: JSON.stringify({ email, code }),
+                    });
+                    if (!res.ok) {
+                        const err = await res.json().catch(() => ({}));
+                        return { error: `Verification failed: ${err.error || res.statusText}` };
+                    }
+                    const data = await res.json();
+                    try {
+                        const configRes = await fetch('http://127.0.0.1:5050/api/plugins/config', {
+                            method: 'POST',
+                            headers: { 'Content-Type': 'application/json' },
+                            body: JSON.stringify({
+                                name: '@openwriter/plugin-publish',
+                                config: { 'api-key': data.apiKey },
+                            }),
+                        });
+                        if (configRes.ok) {
+                            return {
+                                success: true,
+                                userId: data.userId,
+                                message: 'Authenticated and API key saved to plugin config. You can now use all Publish tools.',
+                            };
+                        }
+                    }
+                    catch {
+                        // Config save failed — fall back to returning key
+                    }
+                    return {
+                        success: true,
+                        userId: data.userId,
+                        apiKey: data.apiKey,
+                        message: 'Authenticated but could not auto-save API key. Please save this key to the plugin config manually.',
+                    };
+                },
+            },
+            // Newsletter tools (send, subscribers, issues, analytics)
+            ...newsletterTools(config),
+            // --- Domain tools ---
+            {
+                name: 'setup_custom_domain',
+                description: 'Set up a custom sending domain for newsletters. Automatically handles SendGrid domain auth, DNS records (auto-added for Cloudflare domains), and sender verification. Follow the next_action field in the response.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        domain: { type: 'string', description: 'Domain to set up (e.g. "yourdomain.com")' },
+                        from_email: {
+                            type: 'string',
+                            description: 'From email address (e.g. "newsletter@yourdomain.com")',
+                        },
+                        from_name: {
+                            type: 'string',
+                            description: 'From display name (e.g. "Your Newsletter")',
+                        },
+                        physical_address: {
+                            type: 'string',
+                            description: 'Physical mailing address for CAN-SPAM compliance (required before sending). E.g. "123 Main St, Portland, OR 97201"',
+                        },
+                    },
+                    required: ['domain', 'from_email'],
+                },
+                handler: async (params) => {
+                    const res = await publishFetch(config, '/newsletter/domains', {
+                        method: 'POST',
+                        body: JSON.stringify({
+                            domain: params.domain,
+                            from_email: params.from_email,
+                            from_name: params.from_name || undefined,
+                            physical_address: params.physical_address || undefined,
+                        }),
+                    });
+                    if (!res.ok) {
+                        const err = await res.json().catch(() => ({}));
+                        return { error: `Failed to setup domain: ${err.error || res.statusText}` };
+                    }
+                    const data = await res.json();
+                    return {
+                        success: true,
+                        domainId: data.domain.id,
+                        domain: data.domain.domain,
+                        dnsRecords: data.dnsRecords,
+                        cloudflare_managed: data.cloudflare_managed,
+                        dns_auto_added: data.dns_auto_added,
+                        sender_verification_sent: data.sender_verification_sent,
+                        next_action: data.next_action,
+                    };
+                },
+            },
+            {
+                name: 'check_domain_status',
+                description: 'Check if a custom domain is fully ready (DNS verified + sender verified). If domain_id omitted, lists all domains with their status.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        domain_id: {
+                            type: 'string',
+                            description: 'Domain ID to check (from setup_custom_domain). Omit to list all domains.',
+                        },
+                    },
+                },
+                handler: async (params) => {
+                    if (!params.domain_id) {
+                        const res = await publishFetch(config, '/newsletter/domains');
+                        if (!res.ok) {
+                            const err = await res.json().catch(() => ({}));
+                            return { error: `Failed to list domains: ${err.error || res.statusText}` };
+                        }
+                        const data = await res.json();
+                        return {
+                            domains: data.domains.map((d) => ({
+                                id: d.id,
+                                domain: d.domain,
+                                fromEmail: d.from_email,
+                                status: d.status,
+                                senderStatus: d.sender_status,
+                                cloudflareManaged: d.cloudflare_managed,
+                                hasPhysicalAddress: !!d.physical_address,
+                            })),
+                        };
+                    }
+                    const res = await publishFetch(config, `/newsletter/domains/${params.domain_id}/verify`, {
+                        method: 'POST',
+                    });
+                    if (!res.ok) {
+                        const err = await res.json().catch(() => ({}));
+                        return { error: `Status check failed: ${err.error || res.statusText}` };
+                    }
+                    const data = await res.json();
+                    return {
+                        domain: data.domain,
+                        dns_verified: data.dns_verified,
+                        sender_verified: data.sender_verified,
+                        fully_ready: data.fully_ready,
+                        next_action: data.next_action,
+                    };
+                },
+            },
+            {
+                name: 'resend_domain_verification',
+                description: 'Resend the SendGrid sender verification email for a custom domain. Use when the user did not receive or cannot find the original verification email.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        domain_id: {
+                            type: 'string',
+                            description: 'Domain ID to resend verification for.',
+                        },
+                    },
+                    required: ['domain_id'],
+                },
+                handler: async (params) => {
+                    const res = await publishFetch(config, `/newsletter/domains/${params.domain_id}/resend-verification`, {
+                        method: 'POST',
+                    });
+                    if (!res.ok) {
+                        const err = await res.json().catch(() => ({}));
+                        return { error: `Resend failed: ${err.error || res.statusText}` };
+                    }
+                    const data = await res.json();
+                    return {
+                        success: true,
+                        message: data.message,
+                    };
+                },
+            },
+            // --- Connection tools ---
+            {
+                name: 'list_connections',
+                description: 'List all connected accounts (X, LinkedIn, newsletter domains) for the active profile.',
+                inputSchema: { type: 'object', properties: {} },
+                handler: async () => {
+                    const server = await getServerModules();
+                    const res = await server.platformFetch('/connections/unified');
+                    if (!res.ok) {
+                        const err = await res.json().catch(() => ({}));
+                        return { error: `Failed to list connections: ${err.error || res.statusText}` };
+                    }
+                    const data = await res.json();
+                    return {
+                        connections: data.connections.map((c) => ({
+                            id: c.id,
+                            provider: c.provider,
+                            display_name: c.display_name,
+                            status: c.status,
+                        })),
+                    };
+                },
+            },
+            {
+                name: 'post_to_x',
+                description: 'Post content to X (Twitter) via a connected account. Requires an active X connection.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        content: { type: 'string', description: 'Tweet text (max 280 characters)' },
+                        connection_id: { type: 'string', description: 'X connection ID. If omitted, uses the first active X connection.' },
+                    },
+                    required: ['content'],
+                },
+                handler: async (params) => {
+                    const connectionId = params.connection_id;
+                    let id = connectionId;
+                    if (!id) {
+                        const server = await getServerModules();
+                        const listRes = await server.platformFetch('/connections');
+                        if (listRes.ok) {
+                            const data = await listRes.json();
+                            const xConn = data.connections.find((c) => c.provider === 'x' && c.status === 'active');
+                            if (xConn)
+                                id = xConn.id;
+                        }
+                    }
+                    if (!id)
+                        return { error: 'No active X connection found. Connect an X account first.' };
+                    const server = await getServerModules();
+                    const res = await server.platformFetch(`/connections/${id}/post`, {
+                        method: 'POST',
+                        body: JSON.stringify({ content: params.content }),
+                    });
+                    const data = await res.json();
+                    if (!res.ok)
+                        return { error: `Post failed: ${data.error || res.statusText}` };
+                    return data;
+                },
+            },
+            {
+                name: 'post_to_linkedin',
+                description: 'Post content to LinkedIn via a connected account. Requires an active LinkedIn connection.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        content: { type: 'string', description: 'Post text' },
+                        connection_id: { type: 'string', description: 'LinkedIn connection ID. If omitted, uses the first active LinkedIn connection.' },
+                    },
+                    required: ['content'],
+                },
+                handler: async (params) => {
+                    const connectionId = params.connection_id;
+                    let id = connectionId;
+                    if (!id) {
+                        const server = await getServerModules();
+                        const listRes = await server.platformFetch('/connections');
+                        if (listRes.ok) {
+                            const data = await listRes.json();
+                            const liConn = data.connections.find((c) => c.provider === 'linkedin' && c.status === 'active');
+                            if (liConn)
+                                id = liConn.id;
+                        }
+                    }
+                    if (!id)
+                        return { error: 'No active LinkedIn connection found. Connect a LinkedIn account first.' };
+                    const server = await getServerModules();
+                    const res = await server.platformFetch(`/connections/${id}/post`, {
+                        method: 'POST',
+                        body: JSON.stringify({ content: params.content }),
+                    });
+                    const data = await res.json();
+                    if (!res.ok)
+                        return { error: `Post failed: ${data.error || res.statusText}` };
+                    return data;
+                },
+            },
+            // --- Scheduler tools ---
+            {
+                name: 'schedule_post',
+                description: 'Schedule content for posting. Modes: queue (next available slot), now (immediate), custom (specific time).',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        content: { type: 'string', description: 'Post content' },
+                        connection_id: { type: 'string', description: 'Target connection ID (use list_connections to find)' },
+                        content_type: { type: 'string', enum: ['tweet', 'x', 'linkedin', 'newsletter'], description: 'Content type' },
+                        mode: { type: 'string', enum: ['queue', 'now', 'custom'], description: 'Scheduling mode (default: queue)' },
+                        scheduled_at: { type: 'string', description: 'ISO datetime for custom mode' },
+                    },
+                    required: ['content', 'content_type'],
+                },
+                handler: async (params) => {
+                    const res = await publishFetch(config, '/scheduler/queue', {
+                        method: 'POST',
+                        body: JSON.stringify({
+                            content: params.content,
+                            content_type: params.content_type,
+                            connection_id: params.connection_id,
+                            mode: params.mode || 'queue',
+                            scheduled_at: params.scheduled_at,
+                        }),
+                    });
+                    const data = await res.json();
+                    if (!res.ok)
+                        return { error: `Schedule failed: ${data.error || res.statusText}` };
+                    return { success: true, item: data.item, message: `Content scheduled for ${data.item?.scheduled_at}` };
+                },
+            },
+            {
+                name: 'list_schedule',
+                description: 'Show upcoming queued items with slot times.',
+                inputSchema: { type: 'object', properties: {} },
+                handler: async () => {
+                    const res = await publishFetch(config, '/scheduler/queue');
+                    const data = await res.json();
+                    if (!res.ok)
+                        return { error: `Failed: ${data.error || res.statusText}` };
+                    return data;
+                },
+            },
+            {
+                name: 'manage_schedule',
+                description: 'Cancel or reschedule a queued item.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        item_id: { type: 'string', description: 'Queue item ID' },
+                        action: { type: 'string', enum: ['cancel', 'reschedule'], description: 'Action to take' },
+                        scheduled_at: { type: 'string', description: 'New ISO datetime (for reschedule)' },
+                    },
+                    required: ['item_id', 'action'],
+                },
+                handler: async (params) => {
+                    const itemId = params.item_id;
+                    const action = params.action;
+                    if (action === 'cancel') {
+                        const res = await publishFetch(config, `/scheduler/queue/${itemId}`, { method: 'DELETE' });
+                        const data = await res.json();
+                        if (!res.ok)
+                            return { error: `Cancel failed: ${data.error || res.statusText}` };
+                        return { success: true, message: 'Item cancelled' };
+                    }
+                    if (action === 'reschedule') {
+                        if (!params.scheduled_at)
+                            return { error: 'scheduled_at required for reschedule' };
+                        const res = await publishFetch(config, `/scheduler/queue/${itemId}`, {
+                            method: 'PATCH',
+                            body: JSON.stringify({ scheduled_at: params.scheduled_at }),
+                        });
+                        const data = await res.json();
+                        if (!res.ok)
+                            return { error: `Reschedule failed: ${data.error || res.statusText}` };
+                        return { success: true, item: data.item };
+                    }
+                    return { error: `Unknown action: ${action}` };
+                },
+            },
+            {
+                name: 'list_slots',
+                description: 'Show all slot templates with filters.',
+                inputSchema: { type: 'object', properties: {} },
+                handler: async () => {
+                    const res = await publishFetch(config, '/scheduler/slots');
+                    const data = await res.json();
+                    if (!res.ok)
+                        return { error: `Failed: ${data.error || res.statusText}` };
+                    return data;
+                },
+            },
+            {
+                name: 'create_slot',
+                description: 'Create a scheduling slot template.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        time: { type: 'string', description: 'Time in HH:MM format' },
+                        days: { type: 'array', items: { type: 'string' }, description: 'Days array (mon, tue, etc.) or ["default"] for every day' },
+                        filter_type: { type: 'string', enum: ['any', 'content_type', 'connection', 'category'], description: 'Slot filter type (default: any)' },
+                        filter_value: { type: 'string', description: 'Filter value (content type name or connection ID)' },
+                        timezone: { type: 'string', description: 'IANA timezone (default: America/New_York)' },
+                    },
+                    required: ['time', 'days'],
+                },
+                handler: async (params) => {
+                    const body = { ...params };
+                    if (typeof body.days === 'string') {
+                        try {
+                            body.days = JSON.parse(body.days);
+                        }
+                        catch { /* leave as-is */ }
+                    }
+                    const res = await publishFetch(config, '/scheduler/slots', {
+                        method: 'POST',
+                        body: JSON.stringify(body),
+                    });
+                    const data = await res.json();
+                    if (!res.ok)
+                        return { error: `Failed: ${data.error || res.statusText}` };
+                    return { success: true, slot: data.slot };
+                },
+            },
+            {
+                name: 'edit_slot',
+                description: 'Edit a slot template.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        slot_id: { type: 'string', description: 'Slot ID to edit' },
+                        time: { type: 'string', description: 'New time in HH:MM format' },
+                        days: { type: 'array', items: { type: 'string' }, description: 'New days array' },
+                        filter_type: { type: 'string', enum: ['any', 'content_type', 'connection', 'category'] },
+                        filter_value: { type: 'string' },
+                        timezone: { type: 'string' },
+                    },
+                    required: ['slot_id'],
+                },
+                handler: async (params) => {
+                    const { slot_id, ...changes } = params;
+                    const res = await publishFetch(config, `/scheduler/slots/${slot_id}`, {
+                        method: 'PATCH',
+                        body: JSON.stringify(changes),
+                    });
+                    const data = await res.json();
+                    if (!res.ok)
+                        return { error: `Failed: ${data.error || res.statusText}` };
+                    return { success: true, ...data };
+                },
+            },
+            // --- Autoplug tools ---
+            {
+                name: 'manage_autoplugs',
+                description: 'Manage autoplug goals, rules, and pool messages. Autoplugs automatically reply to your tweets when they hit engagement thresholds, promoting your content.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        action: {
+                            type: 'string',
+                            enum: ['list_goals', 'create_goal', 'update_goal', 'delete_goal', 'list_pool', 'add_pool_message', 'delete_pool_message', 'create_rule', 'update_rule', 'delete_rule', 'sync_av_key'],
+                            description: 'Action to perform',
+                        },
+                        goal_id: { type: 'string', description: 'Goal ID (for pool/rule operations, update_goal, delete_goal)' },
+                        rule_id: { type: 'string', description: 'Rule ID (for update_rule, delete_rule)' },
+                        message_id: { type: 'string', description: 'Pool message ID (for delete_pool_message)' },
+                        name: { type: 'string', description: 'Goal name (for create_goal, update_goal)' },
+                        link: { type: 'string', description: 'Promo link (for create_goal, update_goal)' },
+                        description: { type: 'string', description: 'Goal description for LLM context (for create_goal, update_goal)' },
+                        enabled: { type: 'boolean', description: 'Enable/disable (for update_goal, update_rule)' },
+                        content: { type: 'string', description: 'Pool message text (for add_pool_message). Use {{link}} as placeholder.' },
+                        metric: { type: 'string', enum: ['likes', 'retweets', 'views'], description: 'Trigger metric (for create_rule, update_rule)' },
+                        threshold: { type: 'number', description: 'Trigger threshold (for create_rule, update_rule)' },
+                        delay_minutes: { type: 'number', description: 'Delay after threshold met (for create_rule, update_rule)' },
+                        mode: { type: 'string', enum: ['static', 'llm', 'hybrid'], description: 'Reply mode (for create_rule, update_rule)' },
+                        av_api_key: { type: 'string', description: 'Author\'s Voice API key (for sync_av_key)' },
+                    },
+                    required: ['action'],
+                },
+                handler: async (params) => {
+                    const action = params.action;
+                    if (action === 'list_goals') {
+                        const res = await publishFetch(config, '/scheduler/autoplugs/goals');
+                        const data = await res.json();
+                        if (!res.ok)
+                            return { error: `Failed: ${data.error || res.statusText}` };
+                        return data;
+                    }
+                    if (action === 'create_goal') {
+                        if (!params.name)
+                            return { error: 'name is required' };
+                        const res = await publishFetch(config, '/scheduler/autoplugs/goals', {
+                            method: 'POST',
+                            body: JSON.stringify({ name: params.name, link: params.link, description: params.description }),
+                        });
+                        const data = await res.json();
+                        if (!res.ok)
+                            return { error: `Failed: ${data.error || res.statusText}` };
+                        return { success: true, goal: data.goal };
+                    }
+                    if (action === 'update_goal') {
+                        if (!params.goal_id)
+                            return { error: 'goal_id is required' };
+                        const changes = {};
+                        if (params.name !== undefined)
+                            changes.name = params.name;
+                        if (params.link !== undefined)
+                            changes.link = params.link;
+                        if (params.description !== undefined)
+                            changes.description = params.description;
+                        if (params.enabled !== undefined)
+                            changes.enabled = params.enabled;
+                        const res = await publishFetch(config, `/scheduler/autoplugs/goals/${params.goal_id}`, {
+                            method: 'PATCH',
+                            body: JSON.stringify(changes),
+                        });
+                        const data = await res.json();
+                        if (!res.ok)
+                            return { error: `Failed: ${data.error || res.statusText}` };
+                        return { success: true, goal: data.goal };
+                    }
+                    if (action === 'delete_goal') {
+                        if (!params.goal_id)
+                            return { error: 'goal_id is required' };
+                        const res = await publishFetch(config, `/scheduler/autoplugs/goals/${params.goal_id}`, { method: 'DELETE' });
+                        const data = await res.json();
+                        if (!res.ok)
+                            return { error: `Failed: ${data.error || res.statusText}` };
+                        return { success: true, message: 'Goal deleted' };
+                    }
+                    if (action === 'list_pool') {
+                        if (!params.goal_id)
+                            return { error: 'goal_id is required' };
+                        const res = await publishFetch(config, `/scheduler/autoplugs/goals/${params.goal_id}/pool`);
+                        const data = await res.json();
+                        if (!res.ok)
+                            return { error: `Failed: ${data.error || res.statusText}` };
+                        return data;
+                    }
+                    if (action === 'add_pool_message') {
+                        if (!params.goal_id)
+                            return { error: 'goal_id is required' };
+                        if (!params.content)
+                            return { error: 'content is required' };
+                        const res = await publishFetch(config, `/scheduler/autoplugs/goals/${params.goal_id}/pool`, {
+                            method: 'POST',
+                            body: JSON.stringify({ content: params.content }),
+                        });
+                        const data = await res.json();
+                        if (!res.ok)
+                            return { error: `Failed: ${data.error || res.statusText}` };
+                        return { success: true, message: data.message };
+                    }
+                    if (action === 'delete_pool_message') {
+                        if (!params.message_id)
+                            return { error: 'message_id is required' };
+                        const res = await publishFetch(config, `/scheduler/autoplugs/pool/${params.message_id}`, { method: 'DELETE' });
+                        const data = await res.json();
+                        if (!res.ok)
+                            return { error: `Failed: ${data.error || res.statusText}` };
+                        return { success: true, message: 'Pool message deleted' };
+                    }
+                    if (action === 'create_rule') {
+                        if (!params.goal_id)
+                            return { error: 'goal_id is required' };
+                        if (!params.metric)
+                            return { error: 'metric is required' };
+                        if (!params.threshold)
+                            return { error: 'threshold is required' };
+                        const res = await publishFetch(config, '/scheduler/autoplugs/rules', {
+                            method: 'POST',
+                            body: JSON.stringify({
+                                goal_id: params.goal_id,
+                                metric: params.metric,
+                                threshold: params.threshold,
+                                delay_minutes: params.delay_minutes ?? 30,
+                                mode: params.mode || 'static',
+                            }),
+                        });
+                        const data = await res.json();
+                        if (!res.ok)
+                            return { error: `Failed: ${data.error || res.statusText}` };
+                        return { success: true, rule: data.rule };
+                    }
+                    if (action === 'update_rule') {
+                        if (!params.rule_id)
+                            return { error: 'rule_id is required' };
+                        const changes = {};
+                        if (params.metric !== undefined)
+                            changes.metric = params.metric;
+                        if (params.threshold !== undefined)
+                            changes.threshold = params.threshold;
+                        if (params.delay_minutes !== undefined)
+                            changes.delay_minutes = params.delay_minutes;
+                        if (params.mode !== undefined)
+                            changes.mode = params.mode;
+                        if (params.enabled !== undefined)
+                            changes.enabled = params.enabled;
+                        const res = await publishFetch(config, `/scheduler/autoplugs/rules/${params.rule_id}`, {
+                            method: 'PATCH',
+                            body: JSON.stringify(changes),
+                        });
+                        const data = await res.json();
+                        if (!res.ok)
+                            return { error: `Failed: ${data.error || res.statusText}` };
+                        return { success: true, rule: data.rule };
+                    }
+                    if (action === 'delete_rule') {
+                        if (!params.rule_id)
+                            return { error: 'rule_id is required' };
+                        const res = await publishFetch(config, `/scheduler/autoplugs/rules/${params.rule_id}`, { method: 'DELETE' });
+                        const data = await res.json();
+                        if (!res.ok)
+                            return { error: `Failed: ${data.error || res.statusText}` };
+                        return { success: true, message: 'Rule deleted' };
+                    }
+                    if (action === 'sync_av_key') {
+                        if (!params.av_api_key)
+                            return { error: 'av_api_key is required' };
+                        const res = await publishFetch(config, '/scheduler/autoplugs/av-key', {
+                            method: 'POST',
+                            body: JSON.stringify({ av_api_key: params.av_api_key }),
+                        });
+                        const data = await res.json();
+                        if (!res.ok)
+                            return { error: `Failed: ${data.error || res.statusText}` };
+                        return { success: true, message: 'AV API key synced to platform for LLM autoplugs' };
+                    }
+                    return { error: `Unknown action: ${action}` };
+                },
+            },
+            {
+                name: 'list_autoplug_tracking',
+                description: 'List tracked tweets with engagement metrics and autoplug status. Shows which tweets are being monitored, their current metrics, and whether autoplugs have fired.',
+                inputSchema: { type: 'object', properties: {} },
+                handler: async () => {
+                    const res = await publishFetch(config, '/scheduler/autoplugs/tracking');
+                    const data = await res.json();
+                    if (!res.ok)
+                        return { error: `Failed: ${data.error || res.statusText}` };
+                    return data;
+                },
+            },
+            {
+                name: 'delete_slot',
+                description: 'Delete a slot template.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        slot_id: { type: 'string', description: 'Slot ID to delete' },
+                    },
+                    required: ['slot_id'],
+                },
+                handler: async (params) => {
+                    const res = await publishFetch(config, `/scheduler/slots/${params.slot_id}`, { method: 'DELETE' });
+                    const data = await res.json();
+                    if (!res.ok)
+                        return { error: `Failed: ${data.error || res.statusText}` };
+                    return { success: true, ...data };
+                },
+            },
+        ];
+    },
+};
+export default plugin;