ralph-cli-sandboxed 0.3.0 → 0.4.0

package/dist/commands/action.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Execute an action from config.json - works both inside and outside containers.
+ *
+ * Inside container: Uses file-based message queue to communicate with host daemon
+ * Outside container: Executes the command directly
+ */
+export declare function action(args: string[]): Promise<void>;

package/dist/commands/action.js

@@ -0,0 +1,276 @@
+import { spawn } from "child_process";
+import { existsSync } from "fs";
+import { loadConfig, isRunningInContainer } from "../utils/config.js";
+import { getMessagesPath, sendMessage, waitForResponse, } from "../utils/message-queue.js";
+/**
+ * Execute an action from config.json - works both inside and outside containers.
+ *
+ * Inside container: Uses file-based message queue to communicate with host daemon
+ * Outside container: Executes the command directly
+ */
+export async function action(args) {
+    // Parse arguments
+    let actionName;
+    let actionArgs = [];
+    let debug = false;
+    let showList = false;
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === "--debug" || arg === "-d") {
+            debug = true;
+        }
+        else if (arg === "--help" || arg === "-h") {
+            showHelp();
+            return;
+        }
+        else if (arg === "--list" || arg === "-l") {
+            showList = true;
+        }
+        else if (!arg.startsWith("-")) {
+            if (!actionName) {
+                actionName = arg;
+            }
+            else {
+                // Collect remaining args as action arguments
+                actionArgs = args.slice(i);
+                break;
+            }
+        }
+    }
+    // Load config
+    let config;
+    try {
+        config = loadConfig();
+    }
+    catch {
+        console.error("Failed to load config. Run 'ralph init' first.");
+        process.exit(1);
+    }
+    // Get available actions from daemon config
+    const daemonActions = config.daemon?.actions || {};
+    const actionNames = Object.keys(daemonActions);
+    // If --list or no action specified, show available actions
+    if (showList || !actionName) {
+        if (actionNames.length === 0) {
+            console.log("No actions configured.");
+            console.log("");
+            console.log("Configure actions in .ralph/config.json:");
+            console.log('  {');
+            console.log('    "daemon": {');
+            console.log('      "actions": {');
+            console.log('        "build": {');
+            console.log('          "command": "./scripts/build.sh",');
+            console.log('          "description": "Build the project"');
+            console.log('        }');
+            console.log('      }');
+            console.log('    }');
+            console.log('  }');
+        }
+        else {
+            console.log("Available actions:");
+            console.log("");
+            for (const [name, actionConfig] of Object.entries(daemonActions)) {
+                const desc = actionConfig.description || actionConfig.command;
+                console.log(`  ${name.padEnd(20)} ${desc}`);
+            }
+            console.log("");
+            console.log("Run an action: ralph action <name> [args...]");
+        }
+        return;
+    }
+    // Validate action exists
+    if (!daemonActions[actionName]) {
+        console.error(`Unknown action: ${actionName}`);
+        console.error("");
+        if (actionNames.length > 0) {
+            console.error(`Available actions: ${actionNames.join(", ")}`);
+        }
+        else {
+            console.error("No actions configured in .ralph/config.json");
+        }
+        process.exit(1);
+    }
+    const actionConfig = daemonActions[actionName];
+    const inContainer = isRunningInContainer();
+    if (debug) {
+        console.log(`[action] Name: ${actionName}`);
+        console.log(`[action] Args: ${actionArgs.join(" ") || "(none)"}`);
+        console.log(`[action] Command: ${actionConfig.command}`);
+        console.log(`[action] In container: ${inContainer}`);
+    }
+    if (inContainer) {
+        // Inside container - use file-based message queue to execute on host
+        await executeViaQueue(actionName, actionArgs, debug);
+    }
+    else {
+        // Outside container - execute directly
+        await executeDirectly(actionConfig.command, actionArgs, debug);
+    }
+}
+/**
+ * Execute action via message queue (when running inside container).
+ */
+async function executeViaQueue(actionName, args, debug) {
+    const messagesPath = getMessagesPath(true);
+    if (!existsSync(messagesPath)) {
+        const ralphDir = "/workspace/.ralph";
+        if (!existsSync(ralphDir)) {
+            console.error("Error: .ralph directory not mounted in container.");
+            console.error("Make sure the container is started with 'ralph docker run'.");
+            process.exit(1);
+        }
+    }
+    // Send message via file queue
+    const messageId = sendMessage(messagesPath, "sandbox", actionName, args.length > 0 ? args : undefined);
+    if (debug) {
+        console.log(`[action] Sent message: ${messageId}`);
+    }
+    console.log(`Executing action: ${actionName}`);
+    console.log("Waiting for daemon response...");
+    // Wait for response with longer timeout for actions that may take time
+    const response = await waitForResponse(messagesPath, messageId, 60000);
+    if (!response) {
+        console.error("No response from daemon (timeout).");
+        console.error("");
+        console.error("Make sure the daemon is running on the host:");
+        console.error("  ralph daemon start");
+        process.exit(1);
+    }
+    if (debug) {
+        console.log(`[action] Response: ${JSON.stringify(response)}`);
+    }
+    // Display output
+    if (response.output) {
+        console.log("");
+        console.log(response.output);
+    }
+    if (response.success) {
+        console.log("");
+        console.log(`Action '${actionName}' completed successfully.`);
+    }
+    else {
+        console.error("");
+        console.error(`Action '${actionName}' failed: ${response.error || "Unknown error"}`);
+        process.exit(1);
+    }
+}
+/**
+ * Execute action directly on host (when running outside container).
+ */
+async function executeDirectly(command, args, debug) {
+    return new Promise((resolve, reject) => {
+        // Build full command with arguments
+        let fullCommand = command;
+        if (args.length > 0) {
+            fullCommand = `${command} ${args.map(a => `"${a.replace(/"/g, '\\"')}"`).join(" ")}`;
+        }
+        if (debug) {
+            console.log(`[action] Executing: ${fullCommand}`);
+        }
+        console.log(`Executing: ${fullCommand}`);
+        console.log("");
+        const proc = spawn(fullCommand, [], {
+            stdio: ["inherit", "pipe", "pipe"],
+            shell: true,
+            cwd: process.cwd(),
+        });
+        // Stream stdout in real-time
+        proc.stdout.on("data", (data) => {
+            process.stdout.write(data);
+        });
+        // Stream stderr in real-time
+        proc.stderr.on("data", (data) => {
+            process.stderr.write(data);
+        });
+        proc.on("close", (code) => {
+            if (code === 0) {
+                console.log("");
+                console.log("Action completed successfully.");
+                resolve();
+            }
+            else {
+                console.error("");
+                console.error(`Action failed with exit code: ${code}`);
+                process.exit(code || 1);
+            }
+        });
+        proc.on("error", (err) => {
+            console.error(`Failed to execute action: ${err.message}`);
+            reject(err);
+        });
+    });
+}
+function showHelp() {
+    console.log(`
+ralph action - Execute host actions from config.json
+
+USAGE:
+  ralph action [name] [args...]    Execute an action
+  ralph action --list              List available actions
+  ralph action --help              Show this help
+
+OPTIONS:
+  -l, --list      List all configured actions
+  -d, --debug     Show debug output
+  -h, --help      Show this help message
+
+DESCRIPTION:
+  This command executes actions defined in the daemon.actions section of
+  .ralph/config.json. When running inside a container, the action is
+  executed on the host via the daemon. When running on the host directly,
+  the action is executed locally.
+
+  Actions are useful for triggering host operations like:
+  - Building Xcode projects (requires host Xcode installation)
+  - Running deployment scripts
+  - Executing platform-specific tools not available in the container
+
+CONFIGURATION:
+  Define actions in .ralph/config.json:
+
+  {
+    "daemon": {
+      "actions": {
+        "build": {
+          "command": "./scripts/build.sh",
+          "description": "Build the project"
+        },
+        "deploy": {
+          "command": "./scripts/deploy.sh --env staging",
+          "description": "Deploy to staging"
+        },
+        "gen_xcode": {
+          "command": "swift package generate-xcodeproj",
+          "description": "Generate Xcode project from Swift package"
+        }
+      }
+    }
+  }
+
+EXAMPLES:
+  # List available actions
+  ralph action --list
+  ralph action
+
+  # Execute an action
+  ralph action build
+  ralph action deploy --env production
+  ralph action gen_xcode
+
+  # Execute with arguments
+  ralph action build --release
+  ralph action deploy staging
+
+SETUP FOR CONTAINER USAGE:
+  1. Define actions in .ralph/config.json
+  2. Start the daemon on the host: ralph daemon start
+  3. Run the container: ralph docker run
+  4. From inside the container: ralph action build
+
+NOTES:
+  - Actions configured in daemon.actions are automatically available to the daemon
+  - When in a container, the daemon must be running to process action requests
+  - Actions have a 60-second timeout when executed via the daemon
+  - Output is streamed in real-time when executing directly on host
+`);
+}

package/dist/commands/chat.js

@@ -7,7 +7,7 @@ import { join, basename } from "path";
 import { spawn } from "child_process";
 import { loadConfig, getRalphDir, isRunningInContainer } from "../utils/config.js";
 import { createTelegramClient } from "../providers/telegram.js";
-import { generateProjectId, formatStatusMessage, } from "../utils/chat-client.js";
+import { generateProjectId, formatStatusMessage, formatStatusForChat, } from "../utils/chat-client.js";
 import { getMessagesPath, sendMessage, waitForResponse, } from "../utils/message-queue.js";
 const CHAT_STATE_FILE = "chat-state.json";
 /**
@@ -74,6 +74,35 @@ function getPrdStatus() {
         return { complete: 0, total: 0, incomplete: 0 };
     }
 }
+/**
+ * Get open (incomplete) categories from the PRD.
+ * Returns unique categories that have at least one incomplete task.
+ */
+function getOpenCategories() {
+    const ralphDir = getRalphDir();
+    const prdPath = join(ralphDir, "prd.json");
+    if (!existsSync(prdPath)) {
+        return [];
+    }
+    try {
+        const content = readFileSync(prdPath, "utf-8");
+        const items = JSON.parse(content);
+        if (!Array.isArray(items)) {
+            return [];
+        }
+        // Get unique categories that have incomplete tasks
+        const openCategories = new Set();
+        for (const item of items) {
+            if (item.passes !== true && item.category) {
+                openCategories.add(item.category);
+            }
+        }
+        return Array.from(openCategories);
+    }
+    catch {
+        return [];
+    }
+}
 /**
  * Add a new task to the PRD.
  */
@@ -163,18 +192,22 @@ async function handleCommand(command, client, config, state, debug) {
     }
     switch (cmd) {
         case "run": {
+            // Check for optional category filter
+            const category = args.length > 0 ? args[0] : undefined;
             // Check PRD status first (from host)
             const prdStatus = getPrdStatus();
             if (prdStatus.incomplete === 0) {
                 await client.sendMessage(chatId, `${state.projectName}: All tasks already complete (${prdStatus.complete}/${prdStatus.total})`);
                 return;
             }
-            await client.sendMessage(chatId, `${state.projectName}: Starting ralph run (${prdStatus.incomplete} tasks remaining)...`);
-            // Send run command to sandbox
-            const response = await sendToSandbox("run", [], debug, 10000);
+            const categoryInfo = category ? ` (category: ${category})` : "";
+            await client.sendMessage(chatId, `${state.projectName}: Starting ralph run${categoryInfo} (${prdStatus.incomplete} tasks remaining)...`);
+            // Send run command to sandbox with optional category argument
+            const runArgs = category ? [category] : [];
+            const response = await sendToSandbox("run", runArgs, debug, 10000);
             if (response) {
                 if (response.success) {
-                    await client.sendMessage(chatId, `${state.projectName}: Ralph run started in sandbox`);
+                    await client.sendMessage(chatId, `${state.projectName}: Ralph run started in sandbox${categoryInfo}`);
                 }
                 else {
                     await client.sendMessage(chatId, `${state.projectName}: Failed to start: ${response.error}`);
@@ -190,16 +223,32 @@ async function handleCommand(command, client, config, state, debug) {
         case "status": {
             // Try sandbox first, fall back to host
             const response = await sendToSandbox("status", [], debug, 5000);
+            let statusMessage;
             if (response?.success && response.output) {
-                await client.sendMessage(chatId, `${state.projectName}:\n${response.output}`);
+                // Strip ANSI codes and progress bar for clean chat output
+                const cleanedOutput = formatStatusForChat(response.output);
+                statusMessage = `${state.projectName}:\n${cleanedOutput}`;
             }
             else {
                 // Fall back to host status
                 const prdStatus = getPrdStatus();
                 const status = prdStatus.incomplete === 0 ? "completed" : "idle";
                 const details = `Progress: ${prdStatus.complete}/${prdStatus.total} tasks complete`;
-                await client.sendMessage(chatId, formatStatusMessage(state.projectName, status, details));
+                statusMessage = formatStatusMessage(state.projectName, status, details);
+            }
+            // Get open categories and create inline buttons (max 4)
+            const openCategories = getOpenCategories();
+            let inlineKeyboard;
+            if (openCategories.length > 0 && openCategories.length <= 4) {
+                // Create a row of buttons, one per category
+                inlineKeyboard = [
+                    openCategories.map((category) => ({
+                        text: `▶ Run ${category}`,
+                        callbackData: `/run ${category}`,
+                    })),
+                ];
             }
+            await client.sendMessage(chatId, statusMessage, { inlineKeyboard });
             break;
         }
         case "add": {
@@ -295,6 +344,41 @@ async function handleCommand(command, client, config, state, debug) {
             }
             break;
         }
+        case "claude": {
+            if (args.length === 0) {
+                await client.sendMessage(chatId, `${state.projectName}: Usage: /claude [prompt]`);
+                return;
+            }
+            const prompt = args.join(" ");
+            await client.sendMessage(chatId, `⏳ ${state.projectName}: Running Claude Code...\n(this may take a few minutes)`);
+            // Send claude command to sandbox with longer timeout (5 minutes)
+            const response = await sendToSandbox("claude", args, debug, 300000);
+            if (response) {
+                let output = response.output || response.error || "(no output)";
+                // Truncate long output
+                if (output.length > 2000) {
+                    output = output.substring(0, 2000) + "\n...(truncated)";
+                }
+                if (response.success) {
+                    await client.sendMessage(chatId, `✅ ${state.projectName}: Claude Code DONE\n\n${output}`);
+                }
+                else {
+                    // Check for version mismatch (sandbox has old version without /claude support)
+                    if (response.error?.includes("Unknown action: claude")) {
+                        await client.sendMessage(chatId, `❌ ${state.projectName}: Claude Code failed - sandbox needs update.\n` +
+                            `The sandbox listener doesn't support /claude. Rebuild your Docker container:\n` +
+                            `  ralph docker build --no-cache`);
+                    }
+                    else {
+                        await client.sendMessage(chatId, `❌ ${state.projectName}: Claude Code FAILED\n\n${output}`);
+                    }
+                }
+            }
+            else {
+                await client.sendMessage(chatId, `❌ ${state.projectName}: No response from sandbox. Is 'ralph listen' running?`);
+            }
+            break;
+        }
         case "help": {
             const helpText = `
 /run - Start automation
@@ -302,6 +386,7 @@ async function handleCommand(command, client, config, state, debug) {
 /add [desc] - Add task
 /exec [cmd] - Shell command
 /action [name] - Run action
+/claude [prompt] - Run Claude Code
 /help - This help
 `.trim();
             await client.sendMessage(chatId, helpText);
@@ -365,6 +450,7 @@ async function startChat(config, debug) {
         console.log("  /add ...     - Add new task to PRD");
         console.log("  /exec ...    - Execute shell command");
         console.log("  /action ...  - Run daemon action");
+        console.log("  /claude ...  - Run Claude Code with prompt (YOLO mode)");
         console.log("  /help        - Show help");
         console.log("");
         console.log("Press Ctrl+C to stop the daemon.");
@@ -538,6 +624,7 @@ CHAT COMMANDS:
   /add [desc]     - Add new task to PRD
   /exec [cmd]     - Execute shell command
   /action [name]  - Run daemon action (e.g., /action build)
+  /claude [prompt] - Run Claude Code with prompt in YOLO mode
   /stop           - Stop running ralph process
   /help           - Show help
 
@@ -580,6 +667,7 @@ EXAMPLES:
   /exec npm test    # Run npm test
   /action build     # Run build action
   /action deploy    # Run deploy action
+  /claude Fix the login bug  # Run Claude Code with prompt
 `);
         return;
     }

package/dist/commands/config.js

@@ -1,11 +1,8 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { render, Box, Text } from "ink";
-import { loadConfig, getPaths } from "../utils/config.js";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render } from "ink";
+import { getPaths } from "../utils/config.js";
 import { existsSync } from "fs";
-// Placeholder Ink app component
-function ConfigEditorApp({ config }) {
-    return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsx(Text, { color: "cyan", bold: true, children: "ralph config" }), _jsx(Text, { children: "TUI Config Editor (work in progress)" }), _jsxs(Box, { marginTop: 1, children: [_jsx(Text, { dimColor: true, children: "Language: " }), _jsx(Text, { children: config.language })] }), _jsxs(Box, { children: [_jsx(Text, { dimColor: true, children: "Check: " }), _jsx(Text, { children: config.checkCommand })] }), _jsxs(Box, { children: [_jsx(Text, { dimColor: true, children: "Test: " }), _jsx(Text, { children: config.testCommand })] }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "Press Ctrl+C to exit" }) })] }));
-}
+import { ConfigEditor } from "../tui/ConfigEditor.js";
 export async function config(args) {
     const subcommand = args[0];
     if (subcommand === "help" || subcommand === "--help" || subcommand === "-h") {
@@ -18,17 +15,8 @@ export async function config(args) {
         console.error("Error: .ralph/config.json not found. Run 'ralph init' first.");
         process.exit(1);
     }
-    // Load configuration
-    let configData;
-    try {
-        configData = loadConfig();
-    }
-    catch (error) {
-        console.error("Error loading config:", error instanceof Error ? error.message : "Unknown error");
-        process.exit(1);
-    }
-    // Render Ink app
-    const { waitUntilExit } = render(_jsx(ConfigEditorApp, { config: configData }));
+    // Render Ink app with ConfigEditor
+    const { waitUntilExit } = render(_jsx(ConfigEditor, {}));
     await waitUntilExit();
 }
 function showConfigHelp() {

package/dist/commands/fix-config.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Main fix-config command handler.
+ */
+export declare function fixConfig(args: string[]): Promise<void>;