ralph-cli-sandboxed 0.4.1 → 0.4.2

package/dist/providers/telegram.js

@@ -4,6 +4,11 @@
  */
 import https from "https";
 import { parseCommand, escapeHtml, } from "../utils/chat-client.js";
+import { ResponderMatcher } from "../utils/responder.js";
+import { loadConfig } from "../utils/config.js";
+import { executeLLMResponder } from "../responders/llm-responder.js";
+import { executeClaudeCodeResponder } from "../responders/claude-code-responder.js";
+import { executeCLIResponder } from "../responders/cli-responder.js";
 export class TelegramChatClient {
     provider = "telegram";
     settings;
@@ -12,9 +17,134 @@ export class TelegramChatClient {
     lastUpdateId = 0;
     pollingTimeout = null;
     debug;
+    responderMatcher = null;
+    respondersConfig = null;
+    botUserId = null;
+    botUsername = null;
     constructor(settings, debug = false) {
         this.settings = settings;
         this.debug = debug;
+        // Initialize responders from config if available
+        this.initializeResponders();
+    }
+    /**
+     * Initialize responder matching from config.
+     */
+    initializeResponders() {
+        try {
+            const config = loadConfig();
+            if (config.chat?.responders) {
+                this.respondersConfig = config.chat.responders;
+                this.responderMatcher = new ResponderMatcher(config.chat.responders);
+                if (this.debug) {
+                    console.log(`[telegram] Initialized ${Object.keys(config.chat.responders).length} responders`);
+                }
+            }
+        }
+        catch {
+            // Config not available or responders not configured
+            if (this.debug) {
+                console.log("[telegram] No responders configured");
+            }
+        }
+    }
+    /**
+     * Execute a responder and return the result.
+     */
+    async executeResponder(match, message) {
+        const { responder } = match;
+        switch (responder.type) {
+            case "llm":
+                return executeLLMResponder(message, responder);
+            case "claude-code":
+                return executeClaudeCodeResponder(message, responder);
+            case "cli":
+                return executeCLIResponder(message, responder);
+            default:
+                return {
+                    success: false,
+                    response: "",
+                    error: `Unknown responder type: ${responder.type}`,
+                };
+        }
+    }
+    /**
+     * Handle a message that might match a responder.
+     * Returns true if a responder was matched and executed.
+     */
+    async handleResponderMessage(message, messageId) {
+        if (!this.responderMatcher) {
+            return false;
+        }
+        const match = this.responderMatcher.matchResponder(message.text);
+        if (!match) {
+            return false;
+        }
+        if (this.debug) {
+            console.log(`[telegram] Matched responder: ${match.name} (type: ${match.responder.type})`);
+        }
+        // Execute the responder
+        const result = await this.executeResponder(match, match.args || message.text);
+        // Send the response (reply to the original message for context)
+        if (result.success) {
+            await this.sendMessage(message.chatId, result.response, {
+                replyToMessageId: messageId,
+            });
+        }
+        else {
+            const errorMsg = result.error
+                ? `Error: ${result.error}`
+                : "An error occurred while processing your message.";
+            await this.sendMessage(message.chatId, errorMsg, {
+                replyToMessageId: messageId,
+            });
+        }
+        return true;
+    }
+    /**
+     * Check if the bot is mentioned in a message.
+     * Handles both @username mentions and direct replies to the bot.
+     */
+    isBotMentioned(update) {
+        const msg = update.message;
+        if (!msg)
+            return false;
+        // Check if this is a reply to the bot's message
+        if (msg.reply_to_message?.from?.id === this.botUserId) {
+            return true;
+        }
+        // Check for @mention in message entities
+        if (msg.entities && this.botUsername) {
+            for (const entity of msg.entities) {
+                if (entity.type === "mention" && msg.text) {
+                    const mention = msg.text.substring(entity.offset, entity.offset + entity.length);
+                    if (mention.toLowerCase() === `@${this.botUsername.toLowerCase()}`) {
+                        return true;
+                    }
+                }
+                if (entity.type === "text_mention" && entity.user?.id === this.botUserId) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    /**
+     * Remove bot mention from message text.
+     */
+    removeBotMention(text) {
+        if (!this.botUsername) {
+            return text;
+        }
+        // Remove @username and any surrounding whitespace
+        const regex = new RegExp(`@${this.botUsername}\\s*`, "gi");
+        return text.replace(regex, "").trim();
+    }
+    /**
+     * Check if a chat is a group chat (group or supergroup).
+     */
+    isGroupChat(chatType) {
+        return chatType === "group" || chatType === "supergroup";
     }
     /**
      * Make a request to the Telegram Bot API.
@@ -128,6 +258,8 @@ export class TelegramChatClient {
                 }
                 if (update.message?.text) {
                     const chatId = String(update.message.chat.id);
+                    const messageId = update.message.message_id;
+                    const chatType = update.message.chat.type;
                     // Check if chat is allowed
                     if (!this.isChatAllowed(chatId)) {
                         if (this.debug) {
@@ -135,12 +267,22 @@ export class TelegramChatClient {
                         }
                         continue;
                     }
+                    // In group chats, only process messages that mention the bot or are replies to the bot
+                    const isGroup = this.isGroupChat(chatType);
+                    const isMention = this.isBotMentioned(update);
+                    // Clean the message text (remove bot mention if present)
+                    let messageText = update.message.text;
+                    if (isMention) {
+                        messageText = this.removeBotMention(messageText);
+                    }
                     const message = {
-                        text: update.message.text,
+                        text: messageText,
                         chatId,
                         senderId: update.message.from ? String(update.message.from.id) : undefined,
                         senderName: update.message.from
-                            ? [update.message.from.first_name, update.message.from.last_name].filter(Boolean).join(" ")
+                            ? [update.message.from.first_name, update.message.from.last_name]
+                                .filter(Boolean)
+                                .join(" ")
                             : undefined,
                         timestamp: new Date(update.message.date * 1000),
                         raw: update,
@@ -156,7 +298,7 @@ export class TelegramChatClient {
                             }
                         }
                     }
-                    // Try to parse as a command
+                    // Try to parse as a command first
                     const command = parseCommand(message.text, message);
                     if (command) {
                         try {
@@ -167,7 +309,39 @@ export class TelegramChatClient {
                                 console.error(`[telegram] Command handler error: ${err}`);
                             }
                             // Send error message to chat
-                            await this.sendMessage(chatId, `Error executing command: ${err instanceof Error ? err.message : "Unknown error"}`);
+                            await this.sendMessage(chatId, `Error executing command: ${err instanceof Error ? err.message : "Unknown error"}`, {
+                                replyToMessageId: messageId,
+                            });
+                        }
+                        continue; // Command handled, don't process as responder message
+                    }
+                    // For non-command messages, route through responders
+                    // In group chats: only respond if bot is mentioned or message is a reply to bot
+                    // In private chats: always respond if responders are configured
+                    const shouldProcessAsResponder = !isGroup || isMention;
+                    if (shouldProcessAsResponder && this.responderMatcher) {
+                        // Check if there's a matching responder or a default responder
+                        const hasDefaultResponder = this.responderMatcher.hasDefaultResponder();
+                        const match = this.responderMatcher.matchResponder(message.text);
+                        if (match) {
+                            try {
+                                const handled = await this.handleResponderMessage(message, messageId);
+                                if (handled) {
+                                    continue;
+                                }
+                            }
+                            catch (err) {
+                                if (this.debug) {
+                                    console.error(`[telegram] Responder error: ${err}`);
+                                }
+                                await this.sendMessage(chatId, `Error processing message: ${err instanceof Error ? err.message : "Unknown error"}`, { replyToMessageId: messageId });
+                                continue;
+                            }
+                        }
+                        else if (isMention && !hasDefaultResponder) {
+                            // Bot was mentioned but no responder matched and no default responder
+                            // Send a helpful message
+                            await this.sendMessage(chatId, "I received your message, but no responders are configured. Use /help for available commands.", { replyToMessageId: messageId });
                         }
                     }
                 }
@@ -189,9 +363,11 @@ export class TelegramChatClient {
         if (this.connected) {
             throw new Error("Already connected");
         }
-        // Verify bot token by calling getMe
+        // Verify bot token by calling getMe and store bot info
         try {
             const me = await this.apiRequest("getMe");
+            this.botUserId = me.id;
+            this.botUsername = me.username || null;
             if (this.debug) {
                 console.log(`[telegram] Connected as @${me.username || me.first_name} (ID: ${me.id})`);
             }
@@ -216,6 +392,10 @@ export class TelegramChatClient {
             text: escapedText,
             parse_mode: "HTML",
         };
+        // Add reply_to_message_id for context in group chats
+        if (options?.replyToMessageId) {
+            body.reply_to_message_id = options.replyToMessageId;
+        }
         // Convert generic InlineButton format to Telegram's InlineKeyboardMarkup
         if (options?.inlineKeyboard && options.inlineKeyboard.length > 0) {
             const inlineKeyboard = options.inlineKeyboard.map((row) => row.map((button) => ({

package/dist/responders/claude-code-responder.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Claude Code Responder - Spawns Claude Code CLI with user prompts.
+ * Executes Claude Code in --dangerously-skip-permissions mode to run autonomously.
+ */
+import { ResponderConfig } from "../utils/config.js";
+import { ResponderResult } from "./llm-responder.js";
+/**
+ * Options for executing a Claude Code responder.
+ */
+export interface ClaudeCodeResponderOptions {
+    /** Callback for progress updates during execution */
+    onProgress?: (output: string) => void;
+    /** Override default timeout in milliseconds */
+    timeout?: number;
+    /** Maximum response length in characters */
+    maxLength?: number;
+    /** Working directory for Claude Code execution */
+    cwd?: string;
+}
+/**
+ * Executes Claude Code with the given prompt.
+ *
+ * Spawns the claude CLI with:
+ * - -p flag for non-interactive prompt mode
+ * - --dangerously-skip-permissions to skip all permission prompts
+ * - --print to get clean output
+ *
+ * @param prompt The user prompt to send to Claude Code
+ * @param responderConfig The responder configuration
+ * @param options Optional execution options
+ * @returns The responder result with response or error
+ */
+export declare function executeClaudeCodeResponder(prompt: string, responderConfig: ResponderConfig, options?: ClaudeCodeResponderOptions): Promise<ResponderResult>;
+/**
+ * Creates a reusable Claude Code responder function.
+ * This is useful for handling multiple messages with the same configuration.
+ *
+ * @param responderConfig The responder configuration
+ * @returns A function that executes the responder with a prompt
+ */
+export declare function createClaudeCodeResponder(responderConfig: ResponderConfig): (prompt: string, options?: ClaudeCodeResponderOptions) => Promise<ResponderResult>;
+/**
+ * Validates that a responder configuration is valid for Claude Code execution.
+ *
+ * @param responderConfig The responder configuration to validate
+ * @returns An error message if invalid, or null if valid
+ */
+export declare function validateClaudeCodeResponder(responderConfig: ResponderConfig): string | null;

package/dist/responders/claude-code-responder.js

@@ -0,0 +1,203 @@
+/**
+ * Claude Code Responder - Spawns Claude Code CLI with user prompts.
+ * Executes Claude Code in --dangerously-skip-permissions mode to run autonomously.
+ */
+import { spawn } from "child_process";
+import { truncateResponse } from "./llm-responder.js";
+/**
+ * Default timeout for Claude Code execution (5 minutes).
+ */
+const DEFAULT_TIMEOUT = 300000;
+/**
+ * Default max length for chat responses (characters).
+ */
+const DEFAULT_MAX_LENGTH = 2000;
+/**
+ * Interval for sending progress updates (milliseconds).
+ */
+const PROGRESS_INTERVAL = 5000;
+/**
+ * Executes Claude Code with the given prompt.
+ *
+ * Spawns the claude CLI with:
+ * - -p flag for non-interactive prompt mode
+ * - --dangerously-skip-permissions to skip all permission prompts
+ * - --print to get clean output
+ *
+ * @param prompt The user prompt to send to Claude Code
+ * @param responderConfig The responder configuration
+ * @param options Optional execution options
+ * @returns The responder result with response or error
+ */
+export async function executeClaudeCodeResponder(prompt, responderConfig, options) {
+    const timeout = options?.timeout ?? responderConfig.timeout ?? DEFAULT_TIMEOUT;
+    const maxLength = options?.maxLength ?? responderConfig.maxLength ?? DEFAULT_MAX_LENGTH;
+    const cwd = options?.cwd ?? process.cwd();
+    const onProgress = options?.onProgress;
+    return new Promise((resolve) => {
+        let stdout = "";
+        let stderr = "";
+        let killed = false;
+        let lastProgressSent = 0;
+        let progressTimer = null;
+        // Build the command arguments
+        const args = ["-p", prompt, "--dangerously-skip-permissions", "--print"];
+        // Spawn claude process
+        let proc;
+        try {
+            proc = spawn("claude", args, {
+                cwd,
+                stdio: ["ignore", "pipe", "pipe"],
+                env: { ...process.env },
+            });
+        }
+        catch (err) {
+            const error = err instanceof Error ? err.message : String(err);
+            resolve({
+                success: false,
+                response: "",
+                error: `Failed to spawn claude: ${error}`,
+            });
+            return;
+        }
+        // Handle timeout
+        const timeoutTimer = setTimeout(() => {
+            killed = true;
+            proc.kill("SIGTERM");
+            // Give it a moment to terminate gracefully, then force kill
+            setTimeout(() => {
+                try {
+                    proc.kill("SIGKILL");
+                }
+                catch {
+                    // Already dead
+                }
+            }, 2000);
+            if (progressTimer) {
+                clearInterval(progressTimer);
+            }
+            resolve({
+                success: false,
+                response: stdout,
+                error: `Claude Code timed out after ${Math.round(timeout / 1000)} seconds`,
+            });
+        }, timeout);
+        // Set up progress updates
+        if (onProgress) {
+            progressTimer = setInterval(() => {
+                const now = Date.now();
+                if (now - lastProgressSent >= PROGRESS_INTERVAL && stdout.length > 0) {
+                    // Send a progress indicator
+                    const lines = stdout.split("\n");
+                    const lastLine = lines[lines.length - 1] || lines[lines.length - 2] || "";
+                    const truncatedLine = lastLine.length > 100 ? lastLine.substring(0, 100) + "..." : lastLine;
+                    onProgress(`⏳ Working... ${truncatedLine}`);
+                    lastProgressSent = now;
+                }
+            }, PROGRESS_INTERVAL);
+        }
+        // Capture stdout
+        proc.stdout?.on("data", (data) => {
+            stdout += data.toString();
+        });
+        // Capture stderr
+        proc.stderr?.on("data", (data) => {
+            stderr += data.toString();
+        });
+        // Handle process completion
+        proc.on("close", (code) => {
+            if (killed)
+                return;
+            clearTimeout(timeoutTimer);
+            if (progressTimer) {
+                clearInterval(progressTimer);
+            }
+            if (code === 0 || code === null) {
+                // Success - format and truncate output
+                const output = formatClaudeCodeOutput(stdout);
+                const { text, truncated, originalLength } = truncateResponse(output, maxLength);
+                resolve({
+                    success: true,
+                    response: text,
+                    truncated,
+                    originalLength: truncated ? originalLength : undefined,
+                });
+            }
+            else {
+                // Failure
+                const errorMsg = stderr.trim() || `Claude Code exited with code ${code}`;
+                resolve({
+                    success: false,
+                    response: stdout,
+                    error: errorMsg,
+                });
+            }
+        });
+        // Handle spawn errors
+        proc.on("error", (err) => {
+            if (killed)
+                return;
+            clearTimeout(timeoutTimer);
+            if (progressTimer) {
+                clearInterval(progressTimer);
+            }
+            resolve({
+                success: false,
+                response: "",
+                error: `Claude Code error: ${err.message}`,
+            });
+        });
+    });
+}
+/**
+ * Formats Claude Code output for chat display.
+ * Cleans up ANSI codes, excessive whitespace, and formats for readability.
+ */
+function formatClaudeCodeOutput(output) {
+    // Remove ANSI escape codes
+    let cleaned = output.replace(/\x1B\[[0-9;]*[a-zA-Z]/g, "");
+    // Remove carriage returns (used for progress overwriting)
+    cleaned = cleaned.replace(/\r/g, "");
+    // Collapse multiple blank lines into one
+    cleaned = cleaned.replace(/\n{3,}/g, "\n\n");
+    // Trim leading/trailing whitespace
+    cleaned = cleaned.trim();
+    // If output is empty, provide a default message
+    if (!cleaned) {
+        return "(Claude Code completed with no output)";
+    }
+    return cleaned;
+}
+/**
+ * Creates a reusable Claude Code responder function.
+ * This is useful for handling multiple messages with the same configuration.
+ *
+ * @param responderConfig The responder configuration
+ * @returns A function that executes the responder with a prompt
+ */
+export function createClaudeCodeResponder(responderConfig) {
+    return async (prompt, options) => {
+        return executeClaudeCodeResponder(prompt, responderConfig, options);
+    };
+}
+/**
+ * Validates that a responder configuration is valid for Claude Code execution.
+ *
+ * @param responderConfig The responder configuration to validate
+ * @returns An error message if invalid, or null if valid
+ */
+export function validateClaudeCodeResponder(responderConfig) {
+    if (responderConfig.type !== "claude-code") {
+        return `Responder type is "${responderConfig.type}", expected "claude-code"`;
+    }
+    // Check that timeout is reasonable if specified
+    if (responderConfig.timeout !== undefined) {
+        if (responderConfig.timeout < 1000) {
+            return `Timeout ${responderConfig.timeout}ms is too short (minimum: 1000ms)`;
+        }
+        if (responderConfig.timeout > 600000) {
+            return `Timeout ${responderConfig.timeout}ms is too long (maximum: 600000ms / 10 minutes)`;
+        }
+    }
+    return null;
+}

package/dist/responders/cli-responder.d.ts

@@ -0,0 +1,62 @@
+/**
+ * CLI Responder - Executes configured CLI commands with user messages.
+ * Useful for integrating with aider, custom scripts, or other AI CLIs.
+ */
+import { ResponderConfig } from "../utils/config.js";
+import { ResponderResult } from "./llm-responder.js";
+/**
+ * Options for executing a CLI responder.
+ */
+export interface CLIResponderOptions {
+    /** Callback for progress updates during execution */
+    onProgress?: (output: string) => void;
+    /** Override default timeout in milliseconds */
+    timeout?: number;
+    /** Maximum response length in characters */
+    maxLength?: number;
+    /** Working directory for command execution */
+    cwd?: string;
+    /** Additional environment variables */
+    env?: Record<string, string>;
+}
+/**
+ * Replaces {{message}} placeholder in command string with the actual message.
+ * Escapes the message to prevent shell injection.
+ */
+export declare function replaceMessagePlaceholder(command: string, message: string): string;
+/**
+ * Parses a command string into command and arguments.
+ * Handles quoted strings and basic shell syntax.
+ */
+export declare function parseCommand(commandString: string): {
+    command: string;
+    args: string[];
+};
+/**
+ * Executes a CLI command with the given message.
+ *
+ * The command string can include {{message}} placeholder which will be replaced
+ * with the user's message. If no placeholder is present, the message is appended
+ * as an argument.
+ *
+ * @param message The user message to include in the command
+ * @param responderConfig The responder configuration
+ * @param options Optional execution options
+ * @returns The responder result with response or error
+ */
+export declare function executeCLIResponder(message: string, responderConfig: ResponderConfig, options?: CLIResponderOptions): Promise<ResponderResult>;
+/**
+ * Creates a reusable CLI responder function.
+ * This is useful for handling multiple messages with the same configuration.
+ *
+ * @param responderConfig The responder configuration
+ * @returns A function that executes the responder with a message
+ */
+export declare function createCLIResponder(responderConfig: ResponderConfig): (message: string, options?: CLIResponderOptions) => Promise<ResponderResult>;
+/**
+ * Validates that a responder configuration is valid for CLI execution.
+ *
+ * @param responderConfig The responder configuration to validate
+ * @returns An error message if invalid, or null if valid
+ */
+export declare function validateCLIResponder(responderConfig: ResponderConfig): string | null;