@cordbot/agent 1.0.0

package/dist/scheduler/parser.js

@@ -0,0 +1,62 @@
+import yaml from 'js-yaml';
+import fs from 'fs';
+export function parseCronFile(filePath) {
+    if (!fs.existsSync(filePath)) {
+        return { jobs: [] };
+    }
+    const content = fs.readFileSync(filePath, 'utf-8');
+    // Handle empty file
+    if (!content.trim()) {
+        return { jobs: [] };
+    }
+    try {
+        const parsed = yaml.load(content);
+        // Validate structure
+        if (!parsed || typeof parsed !== 'object') {
+            throw new Error('Invalid YAML structure');
+        }
+        if (!Array.isArray(parsed.jobs)) {
+            throw new Error('jobs must be an array');
+        }
+        // Validate each job
+        const jobs = parsed.jobs.map((job, index) => {
+            if (!job.name || typeof job.name !== 'string') {
+                throw new Error(`Job at index ${index} is missing required field: name`);
+            }
+            if (!job.schedule || typeof job.schedule !== 'string') {
+                throw new Error(`Job at index ${index} is missing required field: schedule`);
+            }
+            if (!job.task || typeof job.task !== 'string') {
+                throw new Error(`Job at index ${index} is missing required field: task`);
+            }
+            return {
+                name: job.name,
+                schedule: job.schedule,
+                task: job.task,
+                oneTime: job.oneTime === true, // Optional field, defaults to false
+            };
+        });
+        return { jobs };
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            throw new Error(`Failed to parse cron file: ${error.message}`);
+        }
+        throw new Error('Failed to parse cron file');
+    }
+}
+export function validateCronSchedule(schedule) {
+    // Basic cron format validation: "* * * * *" (minute hour day month weekday)
+    const parts = schedule.trim().split(/\s+/);
+    if (parts.length !== 5) {
+        return false;
+    }
+    // Each part should be either:
+    // - A number
+    // - An asterisk (*)
+    // - A range (e.g., 1-5)
+    // - A list (e.g., 1,3,5)
+    // - A step (e.g., */2)
+    const cronPartRegex = /^(\*|(\d+(-\d+)?(,\d+(-\d+)?)*)(\/\d+)?)$/;
+    return parts.every(part => cronPartRegex.test(part));
+}

package/dist/scheduler/runner.js

@@ -0,0 +1,201 @@
+import cron from 'node-cron';
+import chokidar from 'chokidar';
+import fs from 'fs';
+import yaml from 'js-yaml';
+import { parseCronFile, validateCronSchedule } from './parser.js';
+import { streamToDiscord } from '../agent/stream.js';
+export class CronRunner {
+    client;
+    sessionManager;
+    scheduledTasks = new Map();
+    watchers = new Map();
+    channelMappings = new Map();
+    constructor(client, sessionManager) {
+        this.client = client;
+        this.sessionManager = sessionManager;
+    }
+    /**
+     * Start watching and scheduling cron jobs for all channels
+     */
+    start(channelMappings) {
+        console.log('⏰ Starting cron scheduler...');
+        for (const mapping of channelMappings) {
+            this.channelMappings.set(mapping.channelId, mapping);
+            this.watchCronFile(mapping);
+        }
+        console.log(`✅ Watching ${channelMappings.length} cron files`);
+    }
+    /**
+     * Add a new channel to watch
+     */
+    addChannel(mapping) {
+        this.channelMappings.set(mapping.channelId, mapping);
+        this.watchCronFile(mapping);
+        console.log(`✅ Now watching cron file for #${mapping.channelName}`);
+    }
+    /**
+     * Remove a channel from watching
+     */
+    removeChannel(channelId) {
+        // Stop the watcher
+        const watcher = this.watchers.get(channelId);
+        if (watcher) {
+            watcher.close();
+            this.watchers.delete(channelId);
+        }
+        // Stop all scheduled tasks for this channel
+        this.stopChannelTasks(channelId);
+        // Remove from channel mappings
+        this.channelMappings.delete(channelId);
+        console.log(`⏸️  Stopped watching channel ${channelId}`);
+    }
+    /**
+     * Watch a cron file for changes and schedule jobs
+     */
+    watchCronFile(mapping) {
+        const { cronPath, channelId, folderPath } = mapping;
+        // Initial load
+        this.loadAndScheduleJobs(channelId, cronPath, folderPath);
+        // Watch for changes
+        const watcher = chokidar.watch(cronPath, {
+            persistent: true,
+            ignoreInitial: true,
+        });
+        watcher.on('change', () => {
+            console.log(`🔄 Cron file changed: ${cronPath}`);
+            this.loadAndScheduleJobs(channelId, cronPath, folderPath);
+        });
+        watcher.on('error', (error) => {
+            console.error(`Failed to watch cron file ${cronPath}:`, error);
+        });
+        this.watchers.set(channelId, watcher);
+    }
+    /**
+     * Load cron file and schedule jobs
+     */
+    loadAndScheduleJobs(channelId, cronPath, folderPath) {
+        // Stop existing tasks for this channel
+        this.stopChannelTasks(channelId);
+        try {
+            // Parse cron file
+            const config = parseCronFile(cronPath);
+            if (config.jobs.length === 0) {
+                console.log(`No jobs configured for channel ${channelId}`);
+                return;
+            }
+            // Schedule each job
+            const tasks = [];
+            for (const job of config.jobs) {
+                // Validate cron schedule
+                if (!validateCronSchedule(job.schedule)) {
+                    console.error(`Invalid cron schedule for job "${job.name}": ${job.schedule}`);
+                    continue;
+                }
+                // Schedule the job
+                const task = cron.schedule(job.schedule, async () => {
+                    await this.executeJob(job, channelId, folderPath);
+                });
+                tasks.push({ job, task, channelId, folderPath });
+                console.log(`📅 Scheduled job "${job.name}" for channel ${channelId}: ${job.schedule}`);
+            }
+            this.scheduledTasks.set(channelId, tasks);
+        }
+        catch (error) {
+            console.error(`Failed to load cron file ${cronPath}:`, error);
+        }
+    }
+    /**
+     * Execute a scheduled job
+     */
+    async executeJob(job, channelId, folderPath) {
+        console.log(`⏰ Executing scheduled job: ${job.name}`);
+        try {
+            const channel = this.client.channels.cache.get(channelId);
+            if (!channel) {
+                console.error(`Channel ${channelId} not found`);
+                return;
+            }
+            // Create a session for this job
+            const sessionId = `cron_${Date.now()}_${job.name}`;
+            // Set channel and working directory context for tools
+            this.sessionManager.setChannelContext(sessionId, channel);
+            this.sessionManager.setWorkingDirContext(sessionId, folderPath);
+            try {
+                // Create query for Claude
+                const queryResult = this.sessionManager.createQuery(job.task, null, // New session for each cron job
+                folderPath);
+                // Stream response with trigger message as prefix
+                await streamToDiscord(queryResult, channel, this.sessionManager, sessionId, folderPath, `⏰ **Scheduled task:** ${job.task}`);
+                console.log(`✅ Completed scheduled job: ${job.name}`);
+                // Store the session so the next message in this channel can continue it
+                this.sessionManager.setPendingCronSession(channelId, sessionId, folderPath);
+                // If this is a one-time job, remove it from the cron file
+                if (job.oneTime) {
+                    await this.removeOneTimeJob(channelId, job.name, folderPath);
+                }
+            }
+            finally {
+                // Clear contexts after execution
+                this.sessionManager.clearChannelContext(sessionId);
+                this.sessionManager.clearWorkingDirContext(sessionId);
+            }
+        }
+        catch (error) {
+            console.error(`Failed to execute job "${job.name}":`, error);
+        }
+    }
+    /**
+     * Stop all tasks for a channel
+     */
+    stopChannelTasks(channelId) {
+        const tasks = this.scheduledTasks.get(channelId);
+        if (tasks) {
+            for (const { task, job } of tasks) {
+                task.stop();
+                console.log(`⏸️  Stopped job: ${job.name}`);
+            }
+            this.scheduledTasks.delete(channelId);
+        }
+    }
+    /**
+     * Remove a one-time job after it executes
+     */
+    async removeOneTimeJob(channelId, jobName, folderPath) {
+        try {
+            const mapping = this.channelMappings.get(channelId);
+            if (!mapping) {
+                console.error(`Cannot find channel mapping for ${channelId}`);
+                return;
+            }
+            const cronPath = mapping.cronPath;
+            // Read and parse the cron file
+            const config = parseCronFile(cronPath);
+            // Filter out the completed one-time job
+            const updatedJobs = config.jobs.filter(job => job.name !== jobName);
+            // Write back to file
+            const yamlContent = yaml.dump({ jobs: updatedJobs });
+            fs.writeFileSync(cronPath, yamlContent, 'utf-8');
+            console.log(`🗑️  Removed one-time job: ${jobName}`);
+        }
+        catch (error) {
+            console.error(`Failed to remove one-time job "${jobName}":`, error);
+        }
+    }
+    /**
+     * Stop all scheduled tasks and watchers
+     */
+    stop() {
+        console.log('⏸️  Stopping cron scheduler...');
+        // Stop all scheduled tasks
+        for (const [channelId, tasks] of this.scheduledTasks) {
+            this.stopChannelTasks(channelId);
+        }
+        // Stop all watchers
+        for (const [channelId, watcher] of this.watchers) {
+            watcher.close();
+            console.log(`⏸️  Stopped watching channel ${channelId}`);
+        }
+        this.watchers.clear();
+        console.log('✅ Cron scheduler stopped');
+    }
+}

package/dist/service/config.js

@@ -0,0 +1,2 @@
+// Firebase Cloud Functions URL (not the hosting URL)
+export const SERVICE_URL = process.env.SERVICE_URL || 'https://us-central1-claudebot-34c42.cloudfunctions.net';

package/dist/service/manifest.js

@@ -0,0 +1,27 @@
+export async function fetchManifest(botToken, serviceUrl) {
+    try {
+        const response = await fetch(`${serviceUrl}/getBotManifest`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                data: { botToken },
+            }),
+        });
+        if (!response.ok) {
+            console.error(`Failed to fetch manifest: ${response.status} ${response.statusText}`);
+            return null;
+        }
+        const data = await response.json();
+        if (data.result?.error) {
+            console.error(`Manifest error: ${data.result.error}`);
+            return null;
+        }
+        return data.result;
+    }
+    catch (error) {
+        console.error('Error fetching manifest:', error);
+        return null;
+    }
+}

package/dist/service/token-manager.js

@@ -0,0 +1,143 @@
+import { fetchManifest } from './manifest.js';
+/**
+ * TokenManager handles OAuth token lifecycle:
+ * - Provides fresh tokens to tools
+ * - Automatically refreshes tokens before expiry
+ * - Runs background refresh loop
+ */
+export class TokenManager {
+    botToken;
+    serviceUrl;
+    manifest = null;
+    refreshInterval = null;
+    isRefreshing = false;
+    constructor(botToken, serviceUrl, initialManifest = null) {
+        this.botToken = botToken;
+        this.serviceUrl = serviceUrl;
+        this.manifest = initialManifest;
+    }
+    /**
+     * Start background token refresh
+     * Checks every 5 minutes and refreshes tokens expiring in <10 minutes
+     */
+    startBackgroundRefresh() {
+        if (this.refreshInterval)
+            return;
+        // Check every 5 minutes
+        const checkInterval = 5 * 60 * 1000;
+        this.refreshInterval = setInterval(async () => {
+            await this.refreshIfNeeded();
+        }, checkInterval);
+        console.log('🔄 Token refresh background task started');
+    }
+    /**
+     * Stop background token refresh
+     */
+    stopBackgroundRefresh() {
+        if (this.refreshInterval) {
+            clearInterval(this.refreshInterval);
+            this.refreshInterval = null;
+            console.log('⏸️  Token refresh background task stopped');
+        }
+    }
+    /**
+     * Check if any tokens need refresh and refresh if needed
+     */
+    async refreshIfNeeded() {
+        if (this.isRefreshing || !this.manifest)
+            return;
+        const now = Date.now();
+        const tenMinutes = 10 * 60 * 1000;
+        let needsRefresh = false;
+        // Check if any tokens expire in the next 10 minutes
+        for (const [category, token] of Object.entries(this.manifest.tokens)) {
+            if (token && token.expiresAt) {
+                const timeUntilExpiry = token.expiresAt - now;
+                if (timeUntilExpiry < tenMinutes) {
+                    console.log(`⚠️  ${category} token expires in ${Math.round(timeUntilExpiry / 1000 / 60)} minutes`);
+                    needsRefresh = true;
+                    break;
+                }
+            }
+        }
+        if (needsRefresh) {
+            await this.refreshTokens();
+        }
+    }
+    /**
+     * Force refresh all tokens from service
+     */
+    async refreshTokens() {
+        if (this.isRefreshing) {
+            console.log('⏳ Token refresh already in progress...');
+            return false;
+        }
+        this.isRefreshing = true;
+        try {
+            console.log('🔄 Refreshing tokens from service...');
+            const newManifest = await fetchManifest(this.botToken, this.serviceUrl);
+            if (!newManifest) {
+                console.error('❌ Failed to refresh tokens - service unavailable');
+                this.isRefreshing = false;
+                return false;
+            }
+            this.manifest = newManifest;
+            console.log('✅ Tokens refreshed successfully');
+            this.isRefreshing = false;
+            return true;
+        }
+        catch (error) {
+            console.error('❌ Token refresh failed:', error);
+            this.isRefreshing = false;
+            return false;
+        }
+    }
+    /**
+     * Get a valid token for a category
+     * Automatically refreshes if token is expired or missing
+     */
+    async getToken(category) {
+        if (!this.manifest) {
+            console.error(`❌ No manifest available for ${category}`);
+            return null;
+        }
+        const token = this.manifest.tokens[category];
+        if (!token) {
+            console.error(`❌ No ${category} token in manifest`);
+            return null;
+        }
+        // Check if token is expired or about to expire (within 2 minutes)
+        const now = Date.now();
+        const twoMinutes = 2 * 60 * 1000;
+        const isExpired = token.expiresAt <= now;
+        const isExpiringSoon = token.expiresAt - now < twoMinutes;
+        if (isExpired) {
+            console.log(`⚠️  ${category} token expired, refreshing...`);
+            const refreshed = await this.refreshTokens();
+            if (!refreshed) {
+                return null;
+            }
+            return this.manifest.tokens[category] || null;
+        }
+        if (isExpiringSoon) {
+            console.log(`⚠️  ${category} token expiring soon, refreshing...`);
+            // Refresh in background, but return current token
+            this.refreshTokens().catch(err => {
+                console.error('Background token refresh failed:', err);
+            });
+        }
+        return token;
+    }
+    /**
+     * Get the current manifest
+     */
+    getManifest() {
+        return this.manifest;
+    }
+    /**
+     * Update the manifest (useful for initial setup)
+     */
+    setManifest(manifest) {
+        this.manifest = manifest;
+    }
+}

package/dist/service/types.js

@@ -0,0 +1 @@
+export {};

package/dist/storage/database.js

@@ -0,0 +1,122 @@
+import Database from 'better-sqlite3';
+export class SessionDatabase {
+    db;
+    constructor(dbPath) {
+        this.db = new Database(dbPath);
+    }
+    /**
+     * Create a new session mapping
+     */
+    createMapping(mapping) {
+        const now = new Date().toISOString();
+        const stmt = this.db.prepare(`
+      INSERT INTO session_mappings (
+        discord_thread_id,
+        discord_channel_id,
+        discord_message_id,
+        session_id,
+        working_directory,
+        created_at,
+        last_active_at,
+        status
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+        stmt.run(mapping.discord_thread_id, mapping.discord_channel_id, mapping.discord_message_id, mapping.session_id, mapping.working_directory, now, now, mapping.status);
+    }
+    /**
+     * Get a session mapping by Discord thread ID
+     */
+    getMapping(threadId) {
+        const stmt = this.db.prepare(`
+      SELECT * FROM session_mappings WHERE discord_thread_id = ?
+    `);
+        return stmt.get(threadId);
+    }
+    /**
+     * Get session mapping by session ID
+     */
+    getMappingBySessionId(sessionId) {
+        const stmt = this.db.prepare(`
+      SELECT * FROM session_mappings WHERE session_id = ?
+    `);
+        return stmt.get(sessionId);
+    }
+    /**
+     * Get all sessions for a channel
+     */
+    getChannelSessions(channelId) {
+        const stmt = this.db.prepare(`
+      SELECT * FROM session_mappings WHERE discord_channel_id = ?
+      ORDER BY last_active_at DESC
+    `);
+        return stmt.all(channelId);
+    }
+    /**
+     * Get all active sessions
+     */
+    getAllActive() {
+        const stmt = this.db.prepare(`
+      SELECT * FROM session_mappings WHERE status = 'active'
+      ORDER BY last_active_at DESC
+    `);
+        return stmt.all();
+    }
+    /**
+     * Update last active timestamp for a session
+     */
+    updateLastActive(threadId) {
+        const stmt = this.db.prepare(`
+      UPDATE session_mappings
+      SET last_active_at = ?
+      WHERE discord_thread_id = ?
+    `);
+        stmt.run(new Date().toISOString(), threadId);
+    }
+    /**
+     * Update session ID for a thread
+     */
+    updateSessionId(threadId, newSessionId) {
+        const stmt = this.db.prepare(`
+      UPDATE session_mappings
+      SET session_id = ?, last_active_at = ?
+      WHERE discord_thread_id = ?
+    `);
+        stmt.run(newSessionId, new Date().toISOString(), threadId);
+    }
+    /**
+     * Archive a session
+     */
+    archiveSession(threadId) {
+        const stmt = this.db.prepare(`
+      UPDATE session_mappings
+      SET status = 'archived'
+      WHERE discord_thread_id = ?
+    `);
+        stmt.run(threadId);
+    }
+    /**
+     * Delete a session mapping
+     */
+    deleteMapping(threadId) {
+        const stmt = this.db.prepare(`
+      DELETE FROM session_mappings WHERE discord_thread_id = ?
+    `);
+        stmt.run(threadId);
+    }
+    /**
+     * Get count of active sessions
+     */
+    getActiveCount() {
+        const stmt = this.db.prepare(`
+      SELECT COUNT(*) as count FROM session_mappings WHERE status = 'active'
+    `);
+        const result = stmt.get();
+        return result.count;
+    }
+    /**
+     * Close the database connection
+     */
+    close() {
+        this.db.close();
+    }
+}

package/dist/tools/builtin-loader.js

@@ -0,0 +1,21 @@
+import { createTool as createListJobs } from './cron/list_jobs.js';
+import { createTool as createAddJob } from './cron/add_job.js';
+import { createTool as createRemoveJob } from './cron/remove_job.js';
+import { createTool as createUpdateJob } from './cron/update_job.js';
+import { createTool as createShareFile } from './share_file.js';
+/**
+ * Load built-in tools that don't require authentication
+ * These tools are always available regardless of manifest configuration
+ */
+export function loadBuiltinTools(getCurrentWorkingDir, queueFileForSharing) {
+    const tools = [];
+    // Load cron management tools
+    tools.push(createListJobs(getCurrentWorkingDir));
+    tools.push(createAddJob(getCurrentWorkingDir));
+    tools.push(createRemoveJob(getCurrentWorkingDir));
+    tools.push(createUpdateJob(getCurrentWorkingDir));
+    // Load file sharing tool
+    tools.push(createShareFile(getCurrentWorkingDir, queueFileForSharing));
+    console.log(`  ✓ Loaded ${tools.length} built-in tools`);
+    return tools;
+}

package/dist/tools/cron/add_job.js

@@ -0,0 +1,96 @@
+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('Unique name for this cron job (e.g., "Daily summary", "Weekly report")'),
+    schedule: z.string().describe('Cron schedule in 5-field format: "minute hour day month weekday". Examples: "0 9 * * *" (daily at 9am), "0 9 * * 1" (Mondays at 9am), "*/30 * * * *" (every 30 minutes)'),
+    task: z.string().describe('Description of the task for Claude to execute when this job runs (e.g., "Summarize recent changes", "Generate weekly report")'),
+    oneTime: z.boolean().optional().describe('Set to true for one-time tasks that should be removed after execution. Default: false')
+});
+export function createTool(getCwd) {
+    return tool('cron_add_job', 'Add a new scheduled cron job to this Discord channel. Use this instead of bash cron/at commands - jobs will execute autonomously and post results directly to the Discord channel. Always list jobs first to avoid duplicate names.', schema.shape, async (params) => {
+        try {
+            // Validate cron schedule format
+            if (!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. Example: "0 9 * * *" for daily at 9am.`,
+                                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',
+                                    '0 0 1 * * - First day of every month at midnight'
+                                ]
+                            }, null, 2)
+                        }
+                    ]
+                };
+            }
+            const cwd = getCwd();
+            const cronPath = path.join(cwd, '.claude-cron');
+            // Read existing jobs
+            const config = parseCronFile(cronPath);
+            // Check for duplicate name
+            if (config.jobs.some(job => job.name === params.name)) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({
+                                error: `A job named "${params.name}" already exists. Use a different name or remove the existing job first.`,
+                                existingJob: config.jobs.find(job => job.name === params.name)
+                            }, null, 2)
+                        }
+                    ]
+                };
+            }
+            // Add new job
+            config.jobs.push({
+                name: params.name,
+                schedule: params.schedule,
+                task: params.task,
+                oneTime: params.oneTime || false
+            });
+            // 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}" added successfully!`,
+                            job: {
+                                name: params.name,
+                                schedule: params.schedule,
+                                task: params.task,
+                                oneTime: params.oneTime || false
+                            },
+                            note: 'The job will be automatically scheduled and will start running according to the schedule. Results will be posted to this Discord channel.'
+                        }, null, 2)
+                    }
+                ]
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            error: `Failed to add cron job: ${error instanceof Error ? error.message : 'Unknown error'}`
+                        }, null, 2)
+                    }
+                ]
+            };
+        }
+    });
+}