@cordbot/agent 1.0.0

package/dist/tools/cron/list_jobs.js

@@ -0,0 +1,55 @@
+import { tool } from '@anthropic-ai/claude-agent-sdk';
+import { z } from 'zod';
+import { parseCronFile } from '../../scheduler/parser.js';
+import path from 'path';
+const schema = z.object({});
+export function createTool(getCwd) {
+    return tool('cron_list_jobs', 'List all scheduled cron jobs for this Discord channel. Shows job names, schedules, tasks, and whether they are one-time. Use this to see what jobs are currently configured before adding, updating, or removing jobs.', schema.shape, async () => {
+        try {
+            const cwd = getCwd();
+            const cronPath = path.join(cwd, '.claude-cron');
+            const config = parseCronFile(cronPath);
+            if (config.jobs.length === 0) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({
+                                jobs: [],
+                                message: 'No cron jobs configured for this channel.'
+                            }, null, 2)
+                        }
+                    ]
+                };
+            }
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            jobs: config.jobs.map(job => ({
+                                name: job.name,
+                                schedule: job.schedule,
+                                task: job.task,
+                                oneTime: job.oneTime || false
+                            })),
+                            count: config.jobs.length
+                        }, null, 2)
+                    }
+                ]
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            error: `Failed to list cron jobs: ${error instanceof Error ? error.message : 'Unknown error'}`
+                        }, null, 2)
+                    }
+                ]
+            };
+        }
+    });
+}

package/dist/tools/cron/remove_job.js

@@ -0,0 +1,64 @@
+import { tool } from '@anthropic-ai/claude-agent-sdk';
+import { z } from 'zod';
+import { parseCronFile } from '../../scheduler/parser.js';
+import yaml from 'js-yaml';
+import fs from 'fs';
+import path from 'path';
+const schema = z.object({
+    name: z.string().describe('Name of the cron job to remove')
+});
+export function createTool(getCwd) {
+    return tool('cron_remove_job', 'Remove a scheduled cron job from this Discord channel by name. The job will stop running immediately. Use cron_list_jobs first to see available job names.', schema.shape, async (params) => {
+        try {
+            const cwd = getCwd();
+            const cronPath = path.join(cwd, '.claude-cron');
+            // Read existing jobs
+            const config = parseCronFile(cronPath);
+            // Find the job
+            const jobToRemove = config.jobs.find(job => job.name === params.name);
+            if (!jobToRemove) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({
+                                error: `Job "${params.name}" not found.`,
+                                availableJobs: config.jobs.map(j => j.name)
+                            }, null, 2)
+                        }
+                    ]
+                };
+            }
+            // Remove the job
+            const updatedJobs = config.jobs.filter(job => job.name !== params.name);
+            // Write back to file
+            const yamlContent = yaml.dump({ jobs: updatedJobs });
+            fs.writeFileSync(cronPath, yamlContent, 'utf-8');
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: true,
+                            message: `Cron job "${params.name}" removed successfully!`,
+                            removedJob: jobToRemove,
+                            remainingJobs: updatedJobs.length
+                        }, null, 2)
+                    }
+                ]
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            error: `Failed to remove cron job: ${error instanceof Error ? error.message : 'Unknown error'}`
+                        }, null, 2)
+                    }
+                ]
+            };
+        }
+    });
+}

package/dist/tools/cron/update_job.js

@@ -0,0 +1,97 @@
+import { tool } from '@anthropic-ai/claude-agent-sdk';
+import { z } from 'zod';
+import { parseCronFile, validateCronSchedule } from '../../scheduler/parser.js';
+import yaml from 'js-yaml';
+import fs from 'fs';
+import path from 'path';
+const schema = z.object({
+    name: z.string().describe('Name of the cron job to update'),
+    schedule: z.string().optional().describe('New cron schedule (leave empty to keep current)'),
+    task: z.string().optional().describe('New task description (leave empty to keep current)'),
+    oneTime: z.boolean().optional().describe('Update one-time flag (leave empty to keep current)')
+});
+export function createTool(getCwd) {
+    return tool('cron_update_job', 'Update an existing cron job\'s schedule, task, or one-time setting. You can update one or more fields. Use cron_list_jobs first to see current job details.', schema.shape, async (params) => {
+        try {
+            // Validate new schedule if provided
+            if (params.schedule && !validateCronSchedule(params.schedule)) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({
+                                error: `Invalid cron schedule format: "${params.schedule}". Must be 5 fields: minute hour day month weekday.`,
+                                validFormat: 'minute hour day month weekday',
+                                examples: [
+                                    '0 9 * * * - Every day at 9:00 AM',
+                                    '0 9 * * 1 - Every Monday at 9:00 AM',
+                                    '*/30 * * * * - Every 30 minutes'
+                                ]
+                            }, null, 2)
+                        }
+                    ]
+                };
+            }
+            const cwd = getCwd();
+            const cronPath = path.join(cwd, '.claude-cron');
+            // Read existing jobs
+            const config = parseCronFile(cronPath);
+            // Find the job
+            const jobIndex = config.jobs.findIndex(job => job.name === params.name);
+            if (jobIndex === -1) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({
+                                error: `Job "${params.name}" not found.`,
+                                availableJobs: config.jobs.map(j => j.name)
+                            }, null, 2)
+                        }
+                    ]
+                };
+            }
+            const oldJob = { ...config.jobs[jobIndex] };
+            // Update fields
+            if (params.schedule) {
+                config.jobs[jobIndex].schedule = params.schedule;
+            }
+            if (params.task) {
+                config.jobs[jobIndex].task = params.task;
+            }
+            if (params.oneTime !== undefined) {
+                config.jobs[jobIndex].oneTime = params.oneTime;
+            }
+            // Write back to file
+            const yamlContent = yaml.dump({ jobs: config.jobs });
+            fs.writeFileSync(cronPath, yamlContent, 'utf-8');
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: true,
+                            message: `Cron job "${params.name}" updated successfully!`,
+                            changes: {
+                                before: oldJob,
+                                after: config.jobs[jobIndex]
+                            }
+                        }, null, 2)
+                    }
+                ]
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            error: `Failed to update cron job: ${error instanceof Error ? error.message : 'Unknown error'}`
+                        }, null, 2)
+                    }
+                ]
+            };
+        }
+    });
+}

package/dist/tools/gmail/list_messages.js

@@ -0,0 +1,87 @@
+import { tool } from '@anthropic-ai/claude-agent-sdk';
+import { google } from 'googleapis';
+import { z } from 'zod';
+const gmailListMessagesSchema = z.object({
+    maxResults: z.number().min(1).max(100).default(10).optional().describe('Max messages to return (1-100)'),
+    query: z.string().optional().describe('Gmail search query (e.g., "from:example@gmail.com", "subject:meeting", "is:unread")')
+});
+export function createTool(context) {
+    return tool('gmail_list_messages', 'List email messages from Gmail inbox with optional search query and filters', gmailListMessagesSchema.shape, async (params) => {
+        // Get fresh token from token manager
+        const tokenData = await context.getToken('gmail');
+        if (!tokenData) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            error: 'Gmail token unavailable. Please reconnect Gmail in the dashboard.',
+                            requiresReauth: true
+                        }, null, 2)
+                    }
+                ]
+            };
+        }
+        try {
+            // Initialize Gmail API with fresh token
+            const oauth2Client = new google.auth.OAuth2();
+            oauth2Client.setCredentials({ access_token: tokenData.accessToken });
+            const gmail = google.gmail({ version: 'v1', auth: oauth2Client });
+            // List messages
+            const listResponse = await gmail.users.messages.list({
+                userId: 'me',
+                maxResults: Math.min(params.maxResults || 10, 100),
+                q: params.query
+            });
+            if (!listResponse.data.messages?.length) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({ messages: [], message: 'No messages found.' }, null, 2)
+                        }
+                    ]
+                };
+            }
+            // Fetch message details
+            const messages = await Promise.all(listResponse.data.messages.map(async (msg) => {
+                const detail = await gmail.users.messages.get({
+                    userId: 'me',
+                    id: msg.id,
+                    format: 'metadata',
+                    metadataHeaders: ['Subject', 'From', 'Date']
+                });
+                const headers = detail.data.payload?.headers || [];
+                const getHeader = (name) => headers.find(h => h.name?.toLowerCase() === name.toLowerCase())?.value || '';
+                return {
+                    id: msg.id,
+                    subject: getHeader('Subject'),
+                    from: getHeader('From'),
+                    date: getHeader('Date'),
+                    snippet: detail.data.snippet || ''
+                };
+            }));
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({ messages, totalResults: messages.length }, null, 2)
+                    }
+                ]
+            };
+        }
+        catch (error) {
+            console.error('Gmail API error:', error);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            error: `Failed to list Gmail messages: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                        }, null, 2)
+                    }
+                ]
+            };
+        }
+    });
+}

package/dist/tools/gmail/send_email.js

@@ -0,0 +1,118 @@
+import { tool } from '@anthropic-ai/claude-agent-sdk';
+import { google } from 'googleapis';
+import { z } from 'zod';
+const gmailSendEmailSchema = z.object({
+    to: z.string().email().describe('Recipient email address'),
+    subject: z.string().describe('Email subject line'),
+    body: z.string().describe('Email body content (plain text or HTML)'),
+    cc: z.string().email().optional().describe('CC email address (optional)'),
+    bcc: z.string().email().optional().describe('BCC email address (optional)')
+});
+export function createTool(context) {
+    return tool('gmail_send_email', 'Send an email via Gmail. Requires user approval before sending. The email will be sent from the authenticated Gmail account.', gmailSendEmailSchema.shape, async (params) => {
+        // Request permission from user
+        const permissionMessage = [
+            `Send email to **${params.to}**`,
+            params.cc ? `CC: ${params.cc}` : null,
+            params.bcc ? `BCC: ${params.bcc}` : null,
+            `Subject: "${params.subject}"`,
+            `\nBody preview: ${params.body.slice(0, 100)}${params.body.length > 100 ? '...' : ''}`
+        ].filter(Boolean).join('\n');
+        try {
+            await context.requestPermission(permissionMessage);
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            error: error instanceof Error ? error.message : 'Permission denied',
+                            cancelled: true
+                        }, null, 2)
+                    }
+                ]
+            };
+        }
+        // Get fresh token from token manager
+        const tokenData = await context.getToken('gmail');
+        if (!tokenData) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            error: 'Gmail token unavailable. Please reconnect Gmail in the dashboard.',
+                            requiresReauth: true
+                        }, null, 2)
+                    }
+                ]
+            };
+        }
+        try {
+            // Initialize Gmail API with fresh token
+            const oauth2Client = new google.auth.OAuth2();
+            oauth2Client.setCredentials({ access_token: tokenData.accessToken });
+            const gmail = google.gmail({ version: 'v1', auth: oauth2Client });
+            // Compose email in RFC 2822 format
+            const emailLines = [
+                `To: ${params.to}`,
+                `Subject: ${params.subject}`
+            ];
+            if (params.cc) {
+                emailLines.push(`Cc: ${params.cc}`);
+            }
+            if (params.bcc) {
+                emailLines.push(`Bcc: ${params.bcc}`);
+            }
+            // Add MIME headers
+            emailLines.push('MIME-Version: 1.0');
+            emailLines.push('Content-Type: text/plain; charset=utf-8');
+            emailLines.push(''); // Empty line separates headers from body
+            emailLines.push(params.body);
+            const email = emailLines.join('\r\n');
+            // Encode email in base64url format
+            const encodedEmail = Buffer.from(email)
+                .toString('base64')
+                .replace(/\+/g, '-')
+                .replace(/\//g, '_')
+                .replace(/=+$/, '');
+            // Send email
+            const response = await gmail.users.messages.send({
+                userId: 'me',
+                requestBody: {
+                    raw: encodedEmail
+                }
+            });
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: true,
+                            message: 'Email sent successfully!',
+                            messageId: response.data.id,
+                            threadId: response.data.threadId,
+                            to: params.to,
+                            subject: params.subject
+                        }, null, 2)
+                    }
+                ]
+            };
+        }
+        catch (error) {
+            console.error('Gmail send error:', error);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            error: `Failed to send email: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                            details: error instanceof Error ? error.stack : undefined
+                        }, null, 2)
+                    }
+                ]
+            };
+        }
+    });
+}

package/dist/tools/loader.js

@@ -0,0 +1,84 @@
+import { permissionManager } from '../discord/events.js';
+import { nanoid } from 'nanoid';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+export async function loadDynamicTools(manifest, tokenManager, getCurrentChannel) {
+    const tools = [];
+    // Create tool context with ALL tokens - tools will request what they need
+    const toolContext = {
+        getToken: (category) => tokenManager.getToken(category),
+        requestPermission: async (message) => {
+            const channel = getCurrentChannel();
+            if (!channel) {
+                throw new Error('No Discord channel context available for permission request');
+            }
+            const requestId = nanoid();
+            await permissionManager.requestPermission(channel, message, requestId);
+        }
+    };
+    // Check if there are any tools configured
+    if (!manifest.toolsConfig || Object.keys(manifest.toolsConfig).length === 0) {
+        console.log('  ℹ️  No tools enabled in manifest');
+        return tools;
+    }
+    const toolsDir = __dirname;
+    // Iterate over each domain (e.g., gmail, calendar, etc.)
+    for (const [domain, toolNames] of Object.entries(manifest.toolsConfig)) {
+        await loadDomainTools(domain, toolNames, toolsDir, toolContext, tools);
+    }
+    return tools;
+}
+async function loadDomainTools(domain, toolNames, toolsDir, toolContext, tools) {
+    const domainDir = path.join(toolsDir, domain);
+    // Check if domain folder exists
+    if (!fs.existsSync(domainDir) || !fs.statSync(domainDir).isDirectory()) {
+        console.warn(`  ⚠️  Domain folder not found: ${domain}`);
+        return;
+    }
+    // Load each tool in this domain
+    for (const toolName of toolNames) {
+        const toolId = `${domain}_${toolName}`;
+        // Look for .ts or .js file
+        const possibleFiles = [
+            path.join(domainDir, `${toolName}.ts`),
+            path.join(domainDir, `${toolName}.js`)
+        ];
+        const toolFile = possibleFiles.find(f => fs.existsSync(f));
+        if (!toolFile) {
+            console.warn(`  ⚠️  Tool file not found: ${domain}/${toolName}`);
+            continue;
+        }
+        try {
+            // Dynamically import the tool module
+            const toolModule = await import(toolFile);
+            // Look for the createTool export (or other common patterns)
+            const createFn = toolModule.createTool ||
+                toolModule[`create${toCamelCase(toolId)}Tool`] ||
+                toolModule.default;
+            if (typeof createFn !== 'function') {
+                console.warn(`  ⚠️  Tool ${toolId}: No createTool export found`);
+                continue;
+            }
+            // Create the tool with the context (all tokens available)
+            const tool = createFn(toolContext);
+            tools.push(tool);
+            console.log(`  ✓ Loaded tool: ${toolId}`);
+        }
+        catch (error) {
+            console.error(`  ✗ Failed to load tool ${toolId}:`, error);
+        }
+    }
+}
+/**
+ * Convert snake_case to CamelCase
+ * gmail_send_email -> GmailSendEmail
+ */
+function toCamelCase(str) {
+    return str
+        .split('_')
+        .map(word => word.charAt(0).toUpperCase() + word.slice(1))
+        .join('');
+}

package/dist/tools/share_file.js

@@ -0,0 +1,61 @@
+import { tool } from '@anthropic-ai/claude-agent-sdk';
+import { z } from 'zod';
+import path from 'path';
+import fs from 'fs/promises';
+const schema = z.object({
+    filePath: z.string().describe('Path to file to share with the user via Discord attachment. Can be an absolute path or relative to current working directory.')
+});
+export function createTool(getCwd, queueFileForSharing) {
+    return tool('shareFile', 'Share a file with the user by attaching it to Discord. The file will be attached after your response completes. Use this to send generated diagrams, reports, code files, or any other files you want to share. Accepts absolute paths or paths relative to the current working directory.', schema.shape, async ({ filePath }) => {
+        try {
+            const cwd = getCwd();
+            // If path is absolute, use it directly; otherwise join with cwd
+            const fullPath = path.isAbsolute(filePath) ? filePath : path.join(cwd, filePath);
+            // Validate file exists
+            try {
+                await fs.access(fullPath);
+            }
+            catch {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({
+                                error: `File not found: ${filePath}`,
+                                attemptedPath: fullPath,
+                                workingDirectory: cwd
+                            }, null, 2)
+                        }
+                    ],
+                    isError: true
+                };
+            }
+            // Queue the file for attachment
+            queueFileForSharing(fullPath);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: true,
+                            message: `File "${filePath}" will be attached to Discord after response completes`
+                        }, null, 2)
+                    }
+                ]
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            error: `Failed to queue file: ${error instanceof Error ? error.message : 'Unknown error'}`
+                        }, null, 2)
+                    }
+                ],
+                isError: true
+            };
+        }
+    });
+}

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "@cordbot/agent",
+  "version": "1.0.0",
+  "description": "Discord bot powered by Claude Agent SDK",
+  "type": "module",
+  "bin": {
+    "cordbot": "./bin/cordbot.js"
+  },
+  "files": [
+    "dist",
+    "bin",
+    "templates",
+    "README.md"
+  ],
+  "scripts": {
+    "dev": "tsx watch src/cli.ts",
+    "build": "tsc && chmod +x bin/cordbot.js",
+    "start": "node dist/cli.js",
+    "copy-readme": "node scripts/copy-readme.js",
+    "prepublishOnly": "npm run copy-readme && npm run build",
+    "test": "vitest",
+    "test:ui": "vitest --ui",
+    "test:run": "vitest run"
+  },
+  "keywords": [
+    "discord",
+    "claude",
+    "bot",
+    "ai",
+    "coding",
+    "assistant"
+  ],
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "@anthropic-ai/claude-agent-sdk": "^0.1.0",
+    "@types/better-sqlite3": "^7.6.8",
+    "@types/express": "^5.0.6",
+    "better-sqlite3": "^9.2.2",
+    "chalk": "^5.3.0",
+    "chokidar": "^3.5.3",
+    "discord.js": "^14.14.1",
+    "dotenv": "^16.3.1",
+    "express": "^5.2.1",
+    "googleapis": "^128.0.0",
+    "inquirer": "^9.2.12",
+    "js-yaml": "^4.1.0",
+    "node-cron": "^3.0.3",
+    "open": "^11.0.0",
+    "ora": "^8.0.1",
+    "zod": "^3.24.1"
+  },
+  "devDependencies": {
+    "@types/inquirer": "^9.0.7",
+    "@types/js-yaml": "^4.0.9",
+    "@types/node": "^20.10.6",
+    "@types/node-cron": "^3.0.11",
+    "tsx": "^4.7.0",
+    "typescript": "^5.3.3",
+    "vitest": "^1.2.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

package/templates/.claude-cron.template

@@ -0,0 +1,3 @@
+# Scheduled tasks for this project
+# Results post to #{{CHANNEL_NAME}}
+jobs: []

package/templates/channel-CLAUDE.md.template

@@ -0,0 +1,26 @@
+# {{CHANNEL_NAME}}
+
+<!-- Add channel-specific project context here -->
+
+**Working Directory:** `{{FOLDER_PATH}}`
+
+---
+
+## Automation
+
+This channel supports scheduled autonomous tasks via `.claude-cron`.
+
+**Example `.claude-cron`:**
+```yaml
+jobs:
+  - name: "Daily summary"
+    schedule: "0 9 * * *"
+    task: "Summarize recent changes"
+    postTo: "thread"
+```
+
+Results will be posted as threads in this channel.
+
+---
+
+See the root CLAUDE.md file for general Discord bot behavior and capabilities.