ralph-cli-sandboxed 0.2.9 → 0.4.0

package/dist/index.js

@@ -10,6 +10,13 @@ import { prd, prdAdd, prdList, prdStatus, prdToggle, prdClean, parseListArgs } f
 import { docker } from "./commands/docker.js";
 import { prompt } from "./commands/prompt.js";
 import { fixPrd } from "./commands/fix-prd.js";
+import { fixConfig } from "./commands/fix-config.js";
+import { daemon } from "./commands/daemon.js";
+import { notify } from "./commands/notify.js";
+import { chat } from "./commands/chat.js";
+import { listen } from "./commands/listen.js";
+import { config } from "./commands/config.js";
+import { action } from "./commands/action.js";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 function getPackageInfo() {
@@ -25,7 +32,14 @@ const commands = {
     prd,
     prompt,
     docker,
+    daemon,
+    notify,
+    chat,
+    listen,
+    config,
+    action,
     "fix-prd": (args) => fixPrd(args),
+    "fix-config": (args) => fixConfig(args),
     // Top-level PRD commands (shortcuts)
     add: () => prdAdd(),
     list: (args) => {

package/dist/providers/telegram.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Telegram chat client implementation.
+ * Uses the Telegram Bot API with long polling to receive messages.
+ */
+import { ChatClient, ChatCommandHandler, ChatMessageHandler, TelegramSettings, SendMessageOptions } from "../utils/chat-client.js";
+export declare class TelegramChatClient implements ChatClient {
+    readonly provider: "telegram";
+    private settings;
+    private connected;
+    private polling;
+    private lastUpdateId;
+    private pollingTimeout;
+    private debug;
+    constructor(settings: TelegramSettings, debug?: boolean);
+    /**
+     * Make a request to the Telegram Bot API.
+     */
+    private apiRequest;
+    /**
+     * Check if a chat ID is allowed.
+     */
+    private isChatAllowed;
+    /**
+     * Start long polling for updates.
+     */
+    private poll;
+    connect(onCommand: ChatCommandHandler, onMessage?: ChatMessageHandler): Promise<void>;
+    sendMessage(chatId: string, text: string, options?: SendMessageOptions): Promise<void>;
+    /**
+     * Answer a callback query (acknowledge button press).
+     */
+    answerCallbackQuery(callbackQueryId: string, text?: string): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+}
+/**
+ * Create a Telegram chat client from settings.
+ */
+export declare function createTelegramClient(settings: TelegramSettings, debug?: boolean): ChatClient;

package/dist/providers/telegram.js

@@ -0,0 +1,256 @@
+/**
+ * Telegram chat client implementation.
+ * Uses the Telegram Bot API with long polling to receive messages.
+ */
+import https from "https";
+import { parseCommand, } from "../utils/chat-client.js";
+export class TelegramChatClient {
+    provider = "telegram";
+    settings;
+    connected = false;
+    polling = false;
+    lastUpdateId = 0;
+    pollingTimeout = null;
+    debug;
+    constructor(settings, debug = false) {
+        this.settings = settings;
+        this.debug = debug;
+    }
+    /**
+     * Make a request to the Telegram Bot API.
+     */
+    async apiRequest(method, body) {
+        return new Promise((resolve, reject) => {
+            const url = `https://api.telegram.org/bot${this.settings.botToken}/${method}`;
+            const options = {
+                method: body ? "POST" : "GET",
+                headers: body
+                    ? {
+                        "Content-Type": "application/json",
+                    }
+                    : undefined,
+            };
+            const req = https.request(url, options, (res) => {
+                let data = "";
+                res.on("data", (chunk) => {
+                    data += chunk;
+                });
+                res.on("end", () => {
+                    try {
+                        const response = JSON.parse(data);
+                        if (response.ok && response.result !== undefined) {
+                            resolve(response.result);
+                        }
+                        else {
+                            reject(new Error(`Telegram API error: ${response.description || "Unknown error"} (code: ${response.error_code})`));
+                        }
+                    }
+                    catch (err) {
+                        reject(new Error(`Failed to parse Telegram response: ${data}`));
+                    }
+                });
+            });
+            req.on("error", (err) => {
+                reject(new Error(`Telegram request failed: ${err.message}`));
+            });
+            if (body) {
+                req.write(JSON.stringify(body));
+            }
+            req.end();
+        });
+    }
+    /**
+     * Check if a chat ID is allowed.
+     */
+    isChatAllowed(chatId) {
+        // If no allowed chat IDs specified, allow all
+        if (!this.settings.allowedChatIds || this.settings.allowedChatIds.length === 0) {
+            return true;
+        }
+        return this.settings.allowedChatIds.includes(chatId);
+    }
+    /**
+     * Start long polling for updates.
+     */
+    async poll(onCommand, onMessage) {
+        if (!this.polling)
+            return;
+        try {
+            const updates = await this.apiRequest("getUpdates", {
+                offset: this.lastUpdateId + 1,
+                timeout: 30, // Long polling timeout in seconds
+            });
+            for (const update of updates) {
+                this.lastUpdateId = update.update_id;
+                // Handle callback queries (button presses)
+                if (update.callback_query) {
+                    const callbackQuery = update.callback_query;
+                    const chatId = callbackQuery.message?.chat?.id
+                        ? String(callbackQuery.message.chat.id)
+                        : null;
+                    if (chatId && this.isChatAllowed(chatId) && callbackQuery.data) {
+                        // Acknowledge the callback query
+                        try {
+                            await this.answerCallbackQuery(callbackQuery.id);
+                        }
+                        catch (err) {
+                            if (this.debug) {
+                                console.error(`[telegram] Failed to answer callback query: ${err}`);
+                            }
+                        }
+                        // Create a synthetic message from the callback data
+                        // The callback_data is the command string (e.g., "/run feature")
+                        const message = {
+                            text: callbackQuery.data,
+                            chatId,
+                            senderId: String(callbackQuery.from.id),
+                            senderName: [callbackQuery.from.first_name, callbackQuery.from.last_name]
+                                .filter(Boolean)
+                                .join(" "),
+                            timestamp: new Date(),
+                            raw: update,
+                        };
+                        // Parse and execute the command
+                        const command = parseCommand(message.text, message);
+                        if (command) {
+                            try {
+                                await onCommand(command);
+                            }
+                            catch (err) {
+                                if (this.debug) {
+                                    console.error(`[telegram] Callback command error: ${err}`);
+                                }
+                                await this.sendMessage(chatId, `Error executing command: ${err instanceof Error ? err.message : "Unknown error"}`);
+                            }
+                        }
+                    }
+                    continue;
+                }
+                if (update.message?.text) {
+                    const chatId = String(update.message.chat.id);
+                    // Check if chat is allowed
+                    if (!this.isChatAllowed(chatId)) {
+                        if (this.debug) {
+                            console.log(`[telegram] Ignoring message from unauthorized chat: ${chatId}`);
+                        }
+                        continue;
+                    }
+                    const message = {
+                        text: update.message.text,
+                        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(" ")
+                            : undefined,
+                        timestamp: new Date(update.message.date * 1000),
+                        raw: update,
+                    };
+                    // Call raw message handler if provided
+                    if (onMessage) {
+                        try {
+                            await onMessage(message);
+                        }
+                        catch (err) {
+                            if (this.debug) {
+                                console.error(`[telegram] Message handler error: ${err}`);
+                            }
+                        }
+                    }
+                    // Try to parse as a command
+                    const command = parseCommand(message.text, message);
+                    if (command) {
+                        try {
+                            await onCommand(command);
+                        }
+                        catch (err) {
+                            if (this.debug) {
+                                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"}`);
+                        }
+                    }
+                }
+            }
+        }
+        catch (err) {
+            if (this.debug) {
+                console.error(`[telegram] Poll error: ${err}`);
+            }
+            // Wait a bit before retrying on error
+            await new Promise((resolve) => setTimeout(resolve, 5000));
+        }
+        // Schedule next poll
+        if (this.polling) {
+            this.pollingTimeout = setTimeout(() => this.poll(onCommand, onMessage), 100);
+        }
+    }
+    async connect(onCommand, onMessage) {
+        if (this.connected) {
+            throw new Error("Already connected");
+        }
+        // Verify bot token by calling getMe
+        try {
+            const me = await this.apiRequest("getMe");
+            if (this.debug) {
+                console.log(`[telegram] Connected as @${me.username || me.first_name} (ID: ${me.id})`);
+            }
+        }
+        catch (err) {
+            throw new Error(`Failed to connect to Telegram: ${err instanceof Error ? err.message : "Unknown error"}`);
+        }
+        this.connected = true;
+        this.polling = true;
+        // Start polling
+        this.poll(onCommand, onMessage);
+    }
+    async sendMessage(chatId, text, options) {
+        if (!this.connected) {
+            throw new Error("Not connected");
+        }
+        const body = {
+            chat_id: chatId,
+            text,
+            parse_mode: "HTML",
+        };
+        // Convert generic InlineButton format to Telegram's InlineKeyboardMarkup
+        if (options?.inlineKeyboard && options.inlineKeyboard.length > 0) {
+            const inlineKeyboard = options.inlineKeyboard.map((row) => row.map((button) => ({
+                text: button.text,
+                callback_data: button.callbackData,
+                url: button.url,
+            })));
+            body.reply_markup = { inline_keyboard: inlineKeyboard };
+        }
+        await this.apiRequest("sendMessage", body);
+    }
+    /**
+     * Answer a callback query (acknowledge button press).
+     */
+    async answerCallbackQuery(callbackQueryId, text) {
+        if (!this.connected) {
+            throw new Error("Not connected");
+        }
+        await this.apiRequest("answerCallbackQuery", {
+            callback_query_id: callbackQueryId,
+            text,
+        });
+    }
+    async disconnect() {
+        this.polling = false;
+        this.connected = false;
+        if (this.pollingTimeout) {
+            clearTimeout(this.pollingTimeout);
+            this.pollingTimeout = null;
+        }
+    }
+    isConnected() {
+        return this.connected;
+    }
+}
+/**
+ * Create a Telegram chat client from settings.
+ */
+export function createTelegramClient(settings, debug = false) {
+    return new TelegramChatClient(settings, debug);
+}

package/dist/templates/macos-scripts.d.ts

@@ -0,0 +1,42 @@
+/**
+ * macOS/Swift development script templates
+ * These scripts are generated when Swift + SwiftUI is selected during ralph init
+ */
+/**
+ * Generate gen_xcode.sh script content
+ * This script generates an Xcode project from a Swift package, supporting SwiftUI apps
+ *
+ * Usage: ./scripts/gen_xcode.sh [project_name]
+ *
+ * @param projectName - Default project name (can be overridden by script argument)
+ */
+export declare function generateGenXcodeScript(projectName?: string): string;
+/**
+ * Check if the selected technologies include SwiftUI
+ */
+export declare function hasSwiftUI(technologies: string[]): boolean;
+/**
+ * Check if the selected technologies include Fastlane
+ */
+export declare function hasFastlane(technologies: string[]): boolean;
+/**
+ * Generate Fastfile template for macOS/iOS deployment
+ * This creates a standard Fastfile with beta and release lanes
+ *
+ * @param projectName - Name of the Xcode project/app
+ */
+export declare function generateFastfile(projectName?: string): string;
+/**
+ * Generate Appfile template for Fastlane
+ * This contains app-specific configuration like bundle ID and Apple ID
+ *
+ * @param projectName - Name of the Xcode project/app
+ */
+export declare function generateAppfile(projectName?: string): string;
+/**
+ * Generate README section for Fastlane setup
+ * This provides documentation on how to use Fastlane with the project
+ *
+ * @param projectName - Name of the Xcode project/app
+ */
+export declare function generateFastlaneReadmeSection(projectName?: string): string;