@praveencs/agent 0.9.29 → 0.10.0

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

@@ -0,0 +1,150 @@
+/**
+ * Discord automation tool.
+ * Provides messaging, channel management, and webhook support via the Discord REST API (v10).
+ */
+export async function execute(params) {
+    const { action, ...args } = params;
+    const token = process.env.DISCORD_BOT_TOKEN;
+
+    if (!token && action !== 'send_webhook') {
+        throw new Error('DISCORD_BOT_TOKEN environment variable is not set. Create a bot at https://discord.com/developers/applications');
+    }
+
+    const headers = {
+        'Content-Type': 'application/json',
+        'Authorization': `Bot ${token}`,
+        'User-Agent': 'praveencs-agent-runtime (https://github.com/praveencs87/agent, 1.0.0)'
+    };
+
+    async function discordFetch(method, endpoint, body = null) {
+        const url = `https://discord.com/api/v10${endpoint}`;
+        const options = { method, headers };
+        if (body) options.body = JSON.stringify(body);
+
+        const res = await fetch(url, options);
+        if (res.status === 204) return { success: true };
+
+        const data = await res.json();
+        if (!res.ok) {
+            throw new Error(`Discord API Error (${res.status}): ${JSON.stringify(data)}`);
+        }
+        return data;
+    }
+
+    try {
+        switch (action) {
+            // --- MESSAGING ---
+            case 'send_message':
+                return await discordFetch('POST', `/channels/${args.channel_id}/messages`, {
+                    content: args.content,
+                    embeds: args.embeds || undefined
+                });
+
+            case 'edit_message':
+                return await discordFetch('PATCH', `/channels/${args.channel_id}/messages/${args.message_id}`, {
+                    content: args.content
+                });
+
+            case 'delete_message':
+                return await discordFetch('DELETE', `/channels/${args.channel_id}/messages/${args.message_id}`);
+
+            case 'get_messages':
+                return await discordFetch('GET', `/channels/${args.channel_id}/messages?limit=${args.limit || 50}`);
+
+            // --- WEBHOOKS (no bot token needed) ---
+            case 'send_webhook': {
+                if (!args.webhook_url) throw new Error('webhook_url is required for send_webhook');
+                const res = await fetch(args.webhook_url, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({
+                        content: args.content,
+                        username: args.username || 'Agent Bot',
+                        embeds: args.embeds || undefined
+                    })
+                });
+                if (!res.ok) throw new Error(`Webhook Error (${res.status})`);
+                return { success: true };
+            }
+
+            // --- CHANNELS ---
+            case 'list_channels':
+                return await discordFetch('GET', `/guilds/${args.guild_id}/channels`);
+
+            case 'create_channel':
+                return await discordFetch('POST', `/guilds/${args.guild_id}/channels`, {
+                    name: args.name,
+                    type: args.type || 0, // 0 = text, 2 = voice
+                    topic: args.topic,
+                    parent_id: args.parent_id
+                });
+
+            case 'delete_channel':
+                return await discordFetch('DELETE', `/channels/${args.channel_id}`);
+
+            // --- GUILDS (SERVERS) ---
+            case 'get_guild':
+                return await discordFetch('GET', `/guilds/${args.guild_id}?with_counts=true`);
+
+            case 'list_members':
+                return await discordFetch('GET', `/guilds/${args.guild_id}/members?limit=${args.limit || 100}`);
+
+            // --- ROLES ---
+            case 'list_roles':
+                return await discordFetch('GET', `/guilds/${args.guild_id}/roles`);
+
+            case 'add_role':
+                return await discordFetch('PUT', `/guilds/${args.guild_id}/members/${args.user_id}/roles/${args.role_id}`);
+
+            case 'remove_role':
+                return await discordFetch('DELETE', `/guilds/${args.guild_id}/members/${args.user_id}/roles/${args.role_id}`);
+
+            // --- REACTIONS ---
+            case 'add_reaction':
+                return await discordFetch('PUT', `/channels/${args.channel_id}/messages/${args.message_id}/reactions/${encodeURIComponent(args.emoji)}/@me`);
+
+            default:
+                throw new Error(`Unknown action: ${action}`);
+        }
+    } catch (err) {
+        return { error: err.message, stack: err.stack };
+    }
+}
+
+export const definition = {
+    name: 'discord',
+    description: 'Interact with Discord to send messages, manage channels and roles, use webhooks, and moderate servers. Requires DISCORD_BOT_TOKEN (except for webhooks).',
+    parameters: {
+        type: 'object',
+        required: ['action'],
+        properties: {
+            action: {
+                type: 'string',
+                description: 'The Discord operation to perform',
+                enum: [
+                    'send_message', 'edit_message', 'delete_message', 'get_messages',
+                    'send_webhook',
+                    'list_channels', 'create_channel', 'delete_channel',
+                    'get_guild', 'list_members',
+                    'list_roles', 'add_role', 'remove_role',
+                    'add_reaction'
+                ]
+            },
+            channel_id: { type: 'string', description: 'Discord channel ID (snowflake)' },
+            guild_id: { type: 'string', description: 'Discord server/guild ID (snowflake)' },
+            message_id: { type: 'string', description: 'Message ID (snowflake)' },
+            user_id: { type: 'string', description: 'User ID (snowflake)' },
+            role_id: { type: 'string', description: 'Role ID (snowflake)' },
+            content: { type: 'string', description: 'Message text content' },
+            embeds: { type: 'array', description: 'Array of Discord embed objects for rich messages' },
+            webhook_url: { type: 'string', description: 'Full Discord webhook URL' },
+            username: { type: 'string', description: 'Override username for webhook messages' },
+            name: { type: 'string', description: 'Channel name (for creation)' },
+            type: { type: 'number', description: 'Channel type: 0=text, 2=voice, 4=category' },
+            topic: { type: 'string', description: 'Channel topic' },
+            parent_id: { type: 'string', description: 'Parent category ID for channel creation' },
+            emoji: { type: 'string', description: 'Emoji for reactions (e.g., "👍" or "custom_emoji:123")' },
+            limit: { type: 'number', description: 'Max results to return' }
+        }
+    }
+};

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

@@ -0,0 +1,21 @@
+{
+    "name": "docker",
+    "version": "1.0.0",
+    "description": "Build images, run containers, manage compose stacks, and view logs with Docker.",
+    "author": "Praveen",
+    "category": "DevOps & Cloud",
+    "tags": [
+        "docker",
+        "containers",
+        "devops",
+        "compose"
+    ],
+    "exports": {
+        "tools": [
+            "tools/docker.js"
+        ],
+        "skills": [
+            "skills/docker-manager.md"
+        ]
+    }
+}

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

@@ -0,0 +1,15 @@
+# Docker Manager
+
+## Description
+This skill enables you to manage Docker containers, images, volumes, and compose stacks.
+
+## Instructions
+1. Use `action: "ps"` to list running containers. Add `all: true` to include stopped ones.
+2. To run a container: `action: "run"` with `image`, optional `name`, `ports` (e.g., `["8080:80"]`), `env_vars`, and `volumes`.
+3. For Docker Compose, use `compose_up` / `compose_down` with `cwd` pointing to the directory containing `docker-compose.yml`.
+4. To view container logs: `action: "logs"` with `container` name/ID and optional `tail` (lines).
+5. To execute a command inside a running container: `action: "exec"` with `container` and `command`.
+6. Docker must be installed and the daemon running. Verify with `docker info`.
+
+## Input Variables
+{{input}}

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

@@ -0,0 +1,135 @@
+/**
+ * Docker automation tool.
+ * Manages containers, images, volumes, and compose stacks via the Docker CLI.
+ */
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+
+const execFileAsync = promisify(execFile);
+
+async function dockerCli(args, cwd) {
+    try {
+        const { stdout, stderr } = await execFileAsync('docker', args, {
+            timeout: 60000,
+            maxBuffer: 10 * 1024 * 1024,
+            cwd: cwd || process.cwd(),
+            env: process.env,
+            shell: true
+        });
+        try { return JSON.parse(stdout); } catch { return { output: stdout.trim(), stderr: stderr.trim() }; }
+    } catch (err) {
+        throw new Error(`Docker Error: ${err.stderr || err.message}`);
+    }
+}
+
+export async function execute(params) {
+    const { action, ...args } = params;
+
+    try {
+        switch (action) {
+            // --- CONTAINERS ---
+            case 'ps':
+                return await dockerCli(['ps', '--format', 'json', ...(args.all ? ['-a'] : [])]);
+
+            case 'run':
+                return await dockerCli([
+                    'run', '-d',
+                    ...(args.name ? ['--name', args.name] : []),
+                    ...(args.ports ? args.ports.flatMap(p => ['-p', p]) : []),
+                    ...(args.env_vars ? args.env_vars.flatMap(e => ['-e', e]) : []),
+                    ...(args.volumes ? args.volumes.flatMap(v => ['-v', v]) : []),
+                    args.image
+                ]);
+
+            case 'stop':
+                return await dockerCli(['stop', args.container]);
+
+            case 'rm':
+                return await dockerCli(['rm', ...(args.force ? ['-f'] : []), args.container]);
+
+            case 'logs':
+                return await dockerCli(['logs', '--tail', String(args.tail || 100), args.container]);
+
+            case 'exec':
+                return await dockerCli(['exec', args.container, ...args.command.split(' ')]);
+
+            // --- IMAGES ---
+            case 'images':
+                return await dockerCli(['images', '--format', 'json']);
+
+            case 'build':
+                return await dockerCli([
+                    'build', '-t', args.tag,
+                    ...(args.file ? ['-f', args.file] : []),
+                    args.context || '.'
+                ], args.cwd);
+
+            case 'pull':
+                return await dockerCli(['pull', args.image]);
+
+            case 'rmi':
+                return await dockerCli(['rmi', ...(args.force ? ['-f'] : []), args.image]);
+
+            // --- VOLUMES ---
+            case 'volume_ls':
+                return await dockerCli(['volume', 'ls', '--format', 'json']);
+
+            case 'volume_create':
+                return await dockerCli(['volume', 'create', args.name]);
+
+            // --- COMPOSE ---
+            case 'compose_up':
+                return await dockerCli(['compose', 'up', '-d', ...(args.build ? ['--build'] : [])], args.cwd);
+
+            case 'compose_down':
+                return await dockerCli(['compose', 'down', ...(args.volumes ? ['-v'] : [])], args.cwd);
+
+            case 'compose_ps':
+                return await dockerCli(['compose', 'ps', '--format', 'json'], args.cwd);
+
+            case 'compose_logs':
+                return await dockerCli(['compose', 'logs', '--tail', String(args.tail || 100)], args.cwd);
+
+            default:
+                throw new Error(`Unknown action: ${action}`);
+        }
+    } catch (err) {
+        return { error: err.message, stack: err.stack };
+    }
+}
+
+export const definition = {
+    name: 'docker',
+    description: 'Manage Docker containers, images, volumes, and compose stacks. Requires Docker CLI installed.',
+    parameters: {
+        type: 'object',
+        required: ['action'],
+        properties: {
+            action: {
+                type: 'string',
+                description: 'The Docker operation to perform',
+                enum: [
+                    'ps', 'run', 'stop', 'rm', 'logs', 'exec',
+                    'images', 'build', 'pull', 'rmi',
+                    'volume_ls', 'volume_create',
+                    'compose_up', 'compose_down', 'compose_ps', 'compose_logs'
+                ]
+            },
+            container: { type: 'string', description: 'Container ID or name' },
+            image: { type: 'string', description: 'Docker image name (e.g., nginx:latest)' },
+            name: { type: 'string', description: 'Container or volume name' },
+            tag: { type: 'string', description: 'Image tag for build (e.g., myapp:v1)' },
+            ports: { type: 'array', items: { type: 'string' }, description: 'Port mappings (e.g., ["8080:80"])' },
+            env_vars: { type: 'array', items: { type: 'string' }, description: 'Environment vars (e.g., ["NODE_ENV=prod"])' },
+            volumes: { type: 'array', items: { type: 'string' }, description: 'Volume mounts (e.g., ["./data:/data"])' },
+            command: { type: 'string', description: 'Command to exec inside container' },
+            context: { type: 'string', description: 'Build context path (default: .)' },
+            file: { type: 'string', description: 'Dockerfile path' },
+            cwd: { type: 'string', description: 'Working directory for compose commands' },
+            tail: { type: 'number', description: 'Number of log lines to show' },
+            all: { type: 'boolean', description: 'Show all containers (including stopped)' },
+            force: { type: 'boolean', description: 'Force remove' },
+            build: { type: 'boolean', description: 'Rebuild images on compose up' }
+        }
+    }
+};

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

@@ -0,0 +1,22 @@
+{
+    "name": "firebase",
+    "version": "1.0.0",
+    "description": "Manage Firestore documents, Auth users, and Cloud Storage on Firebase.",
+    "author": "Praveen",
+    "category": "Databases & Backend",
+    "tags": [
+        "firebase",
+        "firestore",
+        "google",
+        "baas",
+        "auth"
+    ],
+    "exports": {
+        "tools": [
+            "tools/firebase.js"
+        ],
+        "skills": [
+            "skills/firebase-manager.md"
+        ]
+    }
+}

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

@@ -0,0 +1,14 @@
+# Firebase Manager
+
+## Description
+This skill enables you to manage Firestore documents, Auth users, and Cloud Storage on Firebase.
+
+## Instructions
+1. For Firestore operations, provide `collection` and `doc_id`. Documents are automatically converted to Firestore's internal format.
+2. To write data, use `action: "set_doc"` with `data` as a plain JSON object. Nested objects and arrays are supported.
+3. Auth operations require `FIREBASE_API_KEY`. Storage and Firestore may need `FIREBASE_TOKEN` or `GOOGLE_ACCESS_TOKEN`.
+4. Storage uses the default bucket `<project-id>.appspot.com`. Override with the `bucket` parameter.
+5. Required env vars: `FIREBASE_PROJECT_ID` (always), `FIREBASE_API_KEY` (for auth), `FIREBASE_TOKEN` (for authenticated operations).
+
+## Input Variables
+{{input}}

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

@@ -0,0 +1,157 @@
+/**
+ * Firebase automation tool.
+ * Provides Firestore CRUD, Auth management, and Storage via the Firebase REST API.
+ */
+export async function execute(params) {
+    const { action, ...args } = params;
+    const projectId = process.env.FIREBASE_PROJECT_ID;
+    const apiKey = process.env.FIREBASE_API_KEY;
+
+    if (!projectId) {
+        throw new Error('FIREBASE_PROJECT_ID environment variable is not set.');
+    }
+
+    const token = process.env.FIREBASE_TOKEN || process.env.GOOGLE_ACCESS_TOKEN;
+
+    async function firestoreFetch(method, path, body = null) {
+        const url = `https://firestore.googleapis.com/v1/projects/${projectId}/databases/(default)/documents${path}`;
+        const headers = { 'Content-Type': 'application/json' };
+        if (token) headers['Authorization'] = `Bearer ${token}`;
+        if (apiKey) headers['x-goog-api-key'] = apiKey;
+
+        const options = { method, headers };
+        if (body) options.body = JSON.stringify(body);
+
+        const res = await fetch(url, options);
+        const data = await res.json();
+        if (!res.ok) throw new Error(`Firestore Error (${res.status}): ${JSON.stringify(data.error || data)}`);
+        return data;
+    }
+
+    /** Convert JS object to Firestore Value format */
+    function toFirestoreValue(val) {
+        if (val === null) return { nullValue: null };
+        if (typeof val === 'string') return { stringValue: val };
+        if (typeof val === 'number') return Number.isInteger(val) ? { integerValue: String(val) } : { doubleValue: val };
+        if (typeof val === 'boolean') return { booleanValue: val };
+        if (Array.isArray(val)) return { arrayValue: { values: val.map(toFirestoreValue) } };
+        if (typeof val === 'object') {
+            const fields = {};
+            for (const [k, v] of Object.entries(val)) fields[k] = toFirestoreValue(v);
+            return { mapValue: { fields } };
+        }
+        return { stringValue: String(val) };
+    }
+
+    function toFirestoreFields(obj) {
+        const fields = {};
+        for (const [k, v] of Object.entries(obj)) fields[k] = toFirestoreValue(v);
+        return fields;
+    }
+
+    try {
+        switch (action) {
+            // --- FIRESTORE ---
+            case 'get_doc':
+                return await firestoreFetch('GET', `/${args.collection}/${args.doc_id}`);
+
+            case 'list_docs':
+                return await firestoreFetch('GET', `/${args.collection}?pageSize=${args.limit || 20}`);
+
+            case 'set_doc':
+                return await firestoreFetch('PATCH', `/${args.collection}/${args.doc_id}`, {
+                    fields: toFirestoreFields(args.data || {})
+                });
+
+            case 'delete_doc':
+                return await firestoreFetch('DELETE', `/${args.collection}/${args.doc_id}`);
+
+            // --- AUTH (Identity Toolkit) ---
+            case 'list_users': {
+                if (!apiKey) throw new Error('FIREBASE_API_KEY required for auth operations');
+                const res = await fetch(
+                    `https://identitytoolkit.googleapis.com/v1/projects/${projectId}/accounts:batchGet`,
+                    {
+                        method: 'POST',
+                        headers: {
+                            'Content-Type': 'application/json',
+                            'Authorization': `Bearer ${token}`
+                        },
+                        body: JSON.stringify({ maxResults: args.limit || 20 })
+                    }
+                );
+                return await res.json();
+            }
+
+            case 'create_user': {
+                if (!apiKey) throw new Error('FIREBASE_API_KEY required for auth operations');
+                const res = await fetch(
+                    `https://identitytoolkit.googleapis.com/v1/accounts:signUp?key=${apiKey}`,
+                    {
+                        method: 'POST',
+                        headers: { 'Content-Type': 'application/json' },
+                        body: JSON.stringify({
+                            email: args.email,
+                            password: args.password,
+                            returnSecureToken: false
+                        })
+                    }
+                );
+                return await res.json();
+            }
+
+            // --- STORAGE ---
+            case 'list_files': {
+                const bucket = args.bucket || `${projectId}.appspot.com`;
+                const prefix = args.prefix ? `&prefix=${encodeURIComponent(args.prefix)}` : '';
+                const res = await fetch(
+                    `https://storage.googleapis.com/storage/v1/b/${bucket}/o?maxResults=${args.limit || 20}${prefix}`,
+                    { headers: token ? { 'Authorization': `Bearer ${token}` } : {} }
+                );
+                return await res.json();
+            }
+
+            case 'delete_file': {
+                const bucket = args.bucket || `${projectId}.appspot.com`;
+                const res = await fetch(
+                    `https://storage.googleapis.com/storage/v1/b/${bucket}/o/${encodeURIComponent(args.path)}`,
+                    {
+                        method: 'DELETE',
+                        headers: token ? { 'Authorization': `Bearer ${token}` } : {}
+                    }
+                );
+                if (!res.ok) throw new Error(`Storage Error: ${res.status}`);
+                return { success: true };
+            }
+
+            default:
+                throw new Error(`Unknown action: ${action}`);
+        }
+    } catch (err) {
+        return { error: err.message, stack: err.stack };
+    }
+}
+
+export const definition = {
+    name: 'firebase',
+    description: 'Manage Firestore docs, Auth users, and Cloud Storage on Firebase. Requires FIREBASE_PROJECT_ID.',
+    parameters: {
+        type: 'object',
+        required: ['action'],
+        properties: {
+            action: {
+                type: 'string',
+                enum: ['get_doc', 'list_docs', 'set_doc', 'delete_doc', 'list_users', 'create_user', 'list_files', 'delete_file']
+            },
+            collection: { type: 'string', description: 'Firestore collection path' },
+            doc_id: { type: 'string', description: 'Document ID' },
+            data: { type: 'object', description: 'Document data for set_doc' },
+            email: { type: 'string', description: 'Email for user creation' },
+            password: { type: 'string', description: 'Password for user creation' },
+            bucket: { type: 'string', description: 'Storage bucket (default: <project>.appspot.com)' },
+            path: { type: 'string', description: 'File path in storage' },
+            prefix: { type: 'string', description: 'File prefix filter' },
+            limit: { type: 'number', description: 'Max results' }
+        }
+    }
+};

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

@@ -0,0 +1,23 @@
+{
+    "name": "github",
+    "version": "1.0.0",
+    "description": "Advanced GitHub automation: manage repositories, pull requests, advanced search, and CI/CD workflows.",
+    "author": "Praveen",
+    "category": "Git & Version Control",
+    "tags": [
+        "github",
+        "git",
+        "ci",
+        "vcs",
+        "actions",
+        "workflows"
+    ],
+    "exports": {
+        "tools": [
+            "tools/github.js"
+        ],
+        "skills": [
+            "skills/github-manager.md"
+        ]
+    }
+}

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

@@ -0,0 +1,15 @@
+# GitHub Manager
+
+## Description
+This skill grants you the ability to interact with the GitHub API to manage repositories, search code globally, execute CI/CD workflows, and handle pull requests or issues.
+
+## Instructions
+1. When asked to perform GitHub operations, identify the appropriate `action` from the `github` tool.
+2. Ensure you have the required parameters (`owner`, `repo`) extracted from the user's prompt or context.
+3. If searching for code across a repository, construct advanced search queries. For example, to find usages of `express` in `praveencs87/agent`, use: `action: "search_code", query: "express repo:praveencs87/agent"`.
+4. To dispatch a GitHub Action workflow, use `dispatch_workflow` and specify the `workflow_id` (either the numeric ID or the filename like `build.yml`). You can pass custom inputs if required.
+5. If the user asks you to list or manage repos, issues, or PRs, fill out the corresponding title and body fields clearly.
+6. The `github` tool requires `GITHUB_TOKEN` to be set in the environment. If the tool returns an error about authentication, inform the user they need to export it.
+
+## Input Variables
+{{input}}