@cordbot/agent 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Christian Alfoni
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,112 @@
+# Cordbot
+
+A Discord bot powered by the Claude Agent SDK that enables autonomous AI assistance directly in your Discord server.
+
+## Overview
+
+Cordbot is a directory-based Discord bot that syncs Discord channels to local folders, maintains persistent conversation sessions in threads, and supports scheduled autonomous tasks. It uses the Claude Agent SDK with full system access (dangerous mode) to read files, run commands, and make code changes.
+
+## Key Features
+
+- **🤖 Autonomous AI Agent**: Full Claude Code SDK capabilities with dangerous mode enabled
+- **💬 Thread-Based Sessions**: Each Discord thread maintains persistent conversation history
+- **📁 Directory-Based**: Each workspace directory has its own configuration and synced channels
+- **📎 File Attachments**: Upload files to Claude or receive generated files back through Discord
+- **⏰ Scheduled Tasks**: Configure autonomous tasks with `.claude-cron` files
+- **🔌 Service Integrations**: Connect Gmail, Google Calendar, and other services via OAuth
+- **🔄 Hot Reload**: Watches for configuration changes and reloads automatically
+
+## Getting Started
+
+Visit **[cordbot.io](https://cordbot.io)** to:
+
+1. Sign in with your Discord account
+2. Configure your bot token and server
+3. Connect service integrations (Gmail, etc.)
+4. Get your agent authentication token
+
+Run the agent:
+
+```bash
+npx @cordbot/agent
+```
+
+The bot will sync Discord channels to folders in your workspace directory, where you can interact with Claude through Discord messages and threads.
+
+## How It Works
+
+1. **Authentication**: Sign in at cordbot.io to configure your bot and get authenticated
+2. **Channel Sync**: Discord channels are synced to local folders in your workspace directory
+3. **Contextual Instructions**: Each channel folder has a `CLAUDE.md` file providing context to Claude
+4. **Thread Sessions**: Start a conversation in Discord and the bot maintains context throughout the thread
+5. **File Attachments**: Send files to Claude by attaching them to Discord messages, or receive files Claude generates
+6. **Scheduled Jobs**: Configure `.claude-cron` files to run autonomous tasks on a schedule
+7. **Service Tools**: Connected services (Gmail, etc.) become available as tools Claude can use
+
+### Working with Files
+
+**Sending files to Claude:**
+
+- Attach files to any Discord message (images, code, documents, etc.)
+- Files are automatically downloaded to the channel folder
+- Claude can read, edit, and process them using its standard tools
+- Existing files with the same name are overwritten
+
+**Receiving files from Claude:**
+
+- Claude can use the `shareFile` tool to send files back to you
+- Files are attached to Discord after Claude's response
+- Works with any file type: generated code, diagrams, reports, etc.
+
+Example:
+
+```
+You: [Attach config.json] "Can you update the timeout to 30 seconds?"
+Claude: [Reads config.json, edits it, uses shareFile to send back]
+Discord: 📎 Shared files: config.json
+```
+
+## Project Structure
+
+This is a monorepo containing:
+
+- **`packages/bot/`** - The agent process and Discord bot
+- **`packages/web-service/`** - Web dashboard for configuration and OAuth flows
+
+## Documentation
+
+- **Agent Documentation**: See [packages/bot/README.md](packages/bot/README.md) for detailed agent usage
+- **Web Service**: Visit [cordbot.io](https://cordbot.io) for setup and configuration
+- **How It Works**: See the documentation section at [cordbot.io](https://cordbot.io) for details on channels, threads, messages, and cron jobs
+
+## Security Warning
+
+Cordbot runs in "dangerous mode" with full system access:
+
+- Full filesystem read/write
+- Bash command execution
+- Network operations
+- Package management
+
+**Only use in trusted environments with controlled Discord access.** Never share your authentication tokens or commit `.env` files to git.
+
+## Development
+
+```bash
+# Install dependencies
+npm install
+
+# Build packages
+npm run build
+
+# Run tests
+npm test
+```
+
+## License
+
+MIT
+
+## Support
+
+For issues, questions, or contributions, please visit the [GitHub repository](https://github.com/yourusername/cordbot).

package/bin/cordbot.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+
+// This file is the entry point for the CLI command
+// It simply imports and runs the CLI module
+import('../dist/cli.js').then(module => {
+  module.run();
+}).catch(err => {
+  console.error('Failed to start cordbot:', err);
+  process.exit(1);
+});

package/dist/agent/manager.js

@@ -0,0 +1,256 @@
+import { query, createSdkMcpServer } from "@anthropic-ai/claude-agent-sdk";
+import { randomUUID } from "crypto";
+import { fetchManifest } from "../service/manifest.js";
+import { loadDynamicTools } from "../tools/loader.js";
+import { loadBuiltinTools } from "../tools/builtin-loader.js";
+import { SERVICE_URL } from "../service/config.js";
+import { TokenManager } from "../service/token-manager.js";
+export class SessionManager {
+    db;
+    sessionsDir;
+    pendingCronSessions = new Map();
+    dynamicMcpServer = null;
+    tokenManager = null;
+    currentChannels = new Map();
+    currentWorkingDirs = new Map();
+    filesToShare = new Map(); // sessionId -> file paths
+    constructor(db, sessionsDir) {
+        this.db = db;
+        this.sessionsDir = sessionsDir;
+    }
+    async initialize(botToken) {
+        // Load built-in tools (always available, no auth needed)
+        const builtinTools = loadBuiltinTools(() => {
+            // Get the working directory for the currently executing session
+            const entries = Array.from(this.currentWorkingDirs.entries());
+            return entries.length > 0 ? entries[0][1] : process.cwd();
+        }, (filePath) => {
+            // Queue file for sharing - get current session
+            const entries = Array.from(this.currentWorkingDirs.entries());
+            if (entries.length > 0) {
+                const sessionId = entries[0][0];
+                this.queueFileForSharing(sessionId, filePath);
+            }
+        });
+        // Fetch manifest from service for authenticated tools
+        const manifest = await fetchManifest(botToken, SERVICE_URL);
+        let dynamicTools = [];
+        if (manifest) {
+            const toolCount = Object.values(manifest.toolsConfig || {}).reduce((sum, tools) => sum + tools.length, 0);
+            console.log(`📦 Manifest loaded: ${toolCount} authenticated tools available`);
+            // Create token manager
+            this.tokenManager = new TokenManager(botToken, SERVICE_URL, manifest);
+            this.tokenManager.startBackgroundRefresh();
+            // Load dynamic tools with token manager and channel getter
+            dynamicTools = await loadDynamicTools(manifest, this.tokenManager, () => {
+                // Get the channel for the currently executing session
+                // This will be set before each query execution
+                const entries = Array.from(this.currentChannels.entries());
+                return entries.length > 0 ? entries[0][1] : null;
+            });
+            if (dynamicTools.length > 0) {
+                console.log(`  ✓ Loaded ${dynamicTools.length} authenticated tools`);
+            }
+        }
+        else {
+            console.log('ℹ️  No manifest - authenticated tools disabled');
+        }
+        // Combine built-in and dynamic tools
+        const allTools = [...builtinTools, ...dynamicTools];
+        if (allTools.length > 0) {
+            // Create SDK MCP server with all tools
+            this.dynamicMcpServer = createSdkMcpServer({
+                name: 'cordbot-tools',
+                version: '1.0.0',
+                tools: allTools
+            });
+            console.log(`✅ Total tools available: ${allTools.length} (${builtinTools.length} built-in + ${dynamicTools.length} authenticated)`);
+        }
+    }
+    /**
+     * Get or create a session for a Discord thread
+     * Returns the session ID to use with query({ resume: sessionId })
+     */
+    async getOrCreateSession(threadId, channelId, messageId, workingDir) {
+        // Check database for existing session
+        const existing = this.db.getMapping(threadId);
+        if (existing) {
+            // Update last active
+            this.db.updateLastActive(threadId);
+            return {
+                sessionId: existing.session_id,
+                isNew: false,
+            };
+        }
+        // Create new session - first query will initialize it
+        const sessionId = `sess_${Date.now()}_${randomUUID()}`;
+        // Store in database
+        this.db.createMapping({
+            discord_thread_id: threadId,
+            discord_channel_id: channelId,
+            discord_message_id: messageId,
+            session_id: sessionId,
+            working_directory: workingDir,
+            status: "active",
+        });
+        return {
+            sessionId,
+            isNew: true,
+        };
+    }
+    /**
+     * Create a session mapping with a specific session ID (for cron sessions)
+     */
+    createMappingWithSessionId(threadId, channelId, messageId, sessionId, workingDir) {
+        this.db.createMapping({
+            discord_thread_id: threadId,
+            discord_channel_id: channelId,
+            discord_message_id: messageId,
+            session_id: sessionId,
+            working_directory: workingDir,
+            status: "active",
+        });
+    }
+    /**
+     * Set the Discord channel for the current session
+     * Must be called before createQuery to enable permission requests
+     */
+    setChannelContext(sessionId, channel) {
+        this.currentChannels.set(sessionId, channel);
+    }
+    /**
+     * Clear the channel context after query execution
+     */
+    clearChannelContext(sessionId) {
+        this.currentChannels.delete(sessionId);
+    }
+    /**
+     * Set the working directory for the current session
+     * Must be called before createQuery to enable built-in tools (cron, etc.)
+     */
+    setWorkingDirContext(sessionId, workingDir) {
+        this.currentWorkingDirs.set(sessionId, workingDir);
+    }
+    /**
+     * Clear the working directory context after query execution
+     */
+    clearWorkingDirContext(sessionId) {
+        this.currentWorkingDirs.delete(sessionId);
+    }
+    /**
+     * Create a query for a user message
+     * Automatically resumes session if sessionId exists
+     */
+    createQuery(userMessage, sessionId, workingDir) {
+        const options = {
+            cwd: workingDir,
+            resume: sessionId || undefined, // Resume if existing, else new
+            includePartialMessages: true, // Get streaming events
+            settingSources: ["project"], // Load root CLAUDE.md + channel CLAUDE.md files + .claude/skills
+            allowDangerouslySkipPermissions: true,
+            permissionMode: "bypassPermissions",
+            tools: { type: "preset", preset: "claude_code" }, // Enable all Claude Code tools
+        };
+        // Add dynamic MCP server if available
+        if (this.dynamicMcpServer) {
+            options.mcpServers = {
+                'cordbot-dynamic-tools': this.dynamicMcpServer
+            };
+        }
+        return query({
+            prompt: userMessage,
+            options,
+        });
+    }
+    async updateSession(sessionId, threadId) {
+        this.db.updateLastActive(threadId);
+    }
+    async updateSessionId(oldSessionId, newSessionId, threadId) {
+        // Update the database mapping with the real SDK session ID
+        const mapping = this.db.getMapping(threadId);
+        if (mapping && mapping.session_id === oldSessionId) {
+            this.db.updateSessionId(threadId, newSessionId);
+            console.log(`📝 Updated session ID: ${oldSessionId} → ${newSessionId}`);
+        }
+    }
+    async archiveOldSessions(daysInactive) {
+        const cutoff = Date.now() - daysInactive * 24 * 60 * 60 * 1000;
+        const oldSessions = this.db.getAllActive().filter((s) => {
+            return new Date(s.last_active_at).getTime() < cutoff;
+        });
+        for (const session of oldSessions) {
+            this.db.archiveSession(session.discord_thread_id);
+        }
+        return oldSessions.length;
+    }
+    getActiveSessionCount() {
+        return this.db.getActiveCount();
+    }
+    getSessionByThreadId(threadId) {
+        const mapping = this.db.getMapping(threadId);
+        if (!mapping)
+            return undefined;
+        return {
+            sessionId: mapping.session_id,
+            threadId: mapping.discord_thread_id,
+            channelId: mapping.discord_channel_id,
+            workingDirectory: mapping.working_directory,
+            created: new Date(mapping.created_at),
+            lastActive: new Date(mapping.last_active_at),
+            status: mapping.status,
+        };
+    }
+    /**
+     * Store a cron session that can be continued with the next message in the channel
+     */
+    setPendingCronSession(channelId, sessionId, workingDir) {
+        this.pendingCronSessions.set(channelId, {
+            sessionId,
+            timestamp: Date.now(),
+            workingDir,
+        });
+    }
+    /**
+     * Get and remove a pending cron session if one exists and is recent (within 1 hour)
+     */
+    getPendingCronSession(channelId) {
+        const pending = this.pendingCronSessions.get(channelId);
+        if (!pending)
+            return null;
+        // Check if it's still valid (within 1 hour)
+        const age = Date.now() - pending.timestamp;
+        const oneHour = 60 * 60 * 1000;
+        if (age > oneHour) {
+            // Expired, remove it
+            this.pendingCronSessions.delete(channelId);
+            return null;
+        }
+        // Valid, remove it (one-time use)
+        this.pendingCronSessions.delete(channelId);
+        return pending;
+    }
+    /**
+     * Queue a file to be shared with the user (attached to Discord)
+     */
+    queueFileForSharing(sessionId, filePath) {
+        const existing = this.filesToShare.get(sessionId) || [];
+        existing.push(filePath);
+        this.filesToShare.set(sessionId, existing);
+    }
+    /**
+     * Get and clear files queued for sharing
+     */
+    getFilesToShare(sessionId) {
+        const files = this.filesToShare.get(sessionId) || [];
+        this.filesToShare.delete(sessionId);
+        return files;
+    }
+    /**
+     * Cleanup token manager on shutdown
+     */
+    shutdown() {
+        if (this.tokenManager) {
+            this.tokenManager.stopBackgroundRefresh();
+        }
+    }
+}