ralph-cli-sandboxed 0.2.9 → 0.4.0

package/dist/commands/config.js

@@ -0,0 +1,51 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render } from "ink";
+import { getPaths } from "../utils/config.js";
+import { existsSync } from "fs";
+import { ConfigEditor } from "../tui/ConfigEditor.js";
+export async function config(args) {
+    const subcommand = args[0];
+    if (subcommand === "help" || subcommand === "--help" || subcommand === "-h") {
+        showConfigHelp();
+        return;
+    }
+    // Check if .ralph/config.json exists
+    const paths = getPaths();
+    if (!existsSync(paths.config)) {
+        console.error("Error: .ralph/config.json not found. Run 'ralph init' first.");
+        process.exit(1);
+    }
+    // Render Ink app with ConfigEditor
+    const { waitUntilExit } = render(_jsx(ConfigEditor, {}));
+    await waitUntilExit();
+}
+function showConfigHelp() {
+    const helpText = `
+ralph config - Interactive TUI configuration editor
+
+USAGE:
+  ralph config          Open the TUI configuration editor
+  ralph config help     Show this help message
+
+DESCRIPTION:
+  Opens an interactive terminal user interface for editing the .ralph/config.json
+  configuration file. Navigate through sections, edit values, and save changes.
+
+KEYBOARD SHORTCUTS:
+  j/k         Navigate up/down
+  Enter       Edit selected field
+  Esc         Go back / Cancel edit
+  S           Save changes
+  Q           Quit (prompts to save if unsaved changes)
+  ?           Show help panel
+
+SECTIONS:
+  Basic       Language, check command, test command
+  Docker      Ports, volumes, environment, packages
+  Daemon      Actions, socket path
+  Claude      MCP servers, skills
+  Chat        Telegram integration
+  Notify      Notification settings
+`;
+    console.log(helpText.trim());
+}

package/dist/commands/daemon.d.ts

@@ -0,0 +1,23 @@
+export interface DaemonAction {
+    command: string;
+    description?: string;
+    ntfyUrl?: string;
+}
+export interface DaemonConfig {
+    enabled?: boolean;
+    actions?: Record<string, DaemonAction>;
+}
+export interface DaemonRequest {
+    action: string;
+    args?: string[];
+}
+export interface DaemonResponse {
+    success: boolean;
+    message?: string;
+    output?: string;
+    error?: string;
+}
+/**
+ * Main daemon command handler.
+ */
+export declare function daemon(args: string[]): Promise<void>;

package/dist/commands/daemon.js

@@ -0,0 +1,422 @@
+import { existsSync, watch } from "fs";
+import { spawn } from "child_process";
+import { loadConfig, getRalphDir, isRunningInContainer } from "../utils/config.js";
+import { getMessagesPath, readMessages, getPendingMessages, respondToMessage, cleanupOldMessages, initializeMessages, } from "../utils/message-queue.js";
+// Telegram client for sending messages (lazy loaded)
+let telegramClient = null;
+let telegramConfig = null;
+/**
+ * Check if Telegram is enabled (has token and not explicitly disabled).
+ */
+function isTelegramEnabled(config) {
+    if (!config.chat?.telegram?.botToken)
+        return false;
+    if (config.chat.telegram.enabled === false)
+        return false;
+    return true;
+}
+/**
+ * Initialize Telegram client if configured.
+ */
+async function initTelegramClient(config) {
+    if (isTelegramEnabled(config)) {
+        telegramConfig = config.chat.telegram;
+        // Dynamic import to avoid circular dependency
+        const { createTelegramClient } = await import("../providers/telegram.js");
+        telegramClient = createTelegramClient(telegramConfig, false);
+    }
+}
+/**
+ * Send a message via Telegram if configured.
+ */
+async function sendTelegramMessage(message) {
+    if (!telegramClient || !telegramConfig) {
+        return { success: false, error: "Telegram not configured" };
+    }
+    try {
+        // Send to all allowed chat IDs, or fail if none configured
+        const chatIds = telegramConfig.allowedChatIds;
+        if (!chatIds || chatIds.length === 0) {
+            return { success: false, error: "No chat IDs configured for Telegram" };
+        }
+        for (const chatId of chatIds) {
+            await telegramClient.sendMessage(chatId, message);
+        }
+        return { success: true };
+    }
+    catch (err) {
+        return { success: false, error: err instanceof Error ? err.message : "Unknown error" };
+    }
+}
+/**
+ * Default actions available to the sandbox.
+ */
+function getDefaultActions(config) {
+    const actions = {
+        ping: {
+            command: "echo pong",
+            description: "Health check - responds with 'pong'",
+        },
+    };
+    // Add notify action based on notifications config
+    if (config.notifications?.provider === "ntfy" && config.notifications.ntfy?.topic) {
+        const server = config.notifications.ntfy.server || "https://ntfy.sh";
+        const topic = config.notifications.ntfy.topic;
+        actions.notify = {
+            command: "curl", // Placeholder - ntfyUrl triggers special handling
+            description: `Send notification via ntfy to ${topic}`,
+            ntfyUrl: `${server}/${topic}`,
+        };
+    }
+    else if (config.notifications?.provider === "command" && config.notifications.command) {
+        actions.notify = {
+            command: config.notifications.command,
+            description: "Send notification to host",
+        };
+    }
+    else if (config.notifyCommand) {
+        // Fallback to deprecated notifyCommand
+        actions.notify = {
+            command: config.notifyCommand,
+            description: "Send notification to host",
+        };
+    }
+    // Add telegram_notify action if Telegram is enabled
+    if (isTelegramEnabled(config)) {
+        actions.telegram_notify = {
+            command: "__telegram__", // Special marker for Telegram handling
+            description: "Send notification via Telegram",
+        };
+    }
+    // Add chat_status action for querying PRD status from container
+    actions.chat_status = {
+        command: "ralph prd status --json 2>/dev/null || echo '{}'",
+        description: "Get PRD status as JSON",
+    };
+    // Add chat_add action for adding PRD tasks from container
+    actions.chat_add = {
+        command: "ralph add",
+        description: "Add a new task to the PRD",
+    };
+    return actions;
+}
+/**
+ * Execute an action command with arguments.
+ * Environment variables are passed to the command:
+ * - RALPH_MESSAGE: The message argument (if provided)
+ */
+async function executeAction(action, args = []) {
+    // Special handling for Telegram
+    if (action.command === "__telegram__") {
+        const message = args.join(" ") || "Ralph notification";
+        const result = await sendTelegramMessage(message);
+        return {
+            success: result.success,
+            output: result.success ? "Sent to Telegram" : "",
+            error: result.error,
+        };
+    }
+    return new Promise((resolve) => {
+        let fullCommand;
+        const message = args.join(" ") || "";
+        // Build environment with RALPH_MESSAGE
+        const env = {
+            ...process.env,
+            RALPH_MESSAGE: message,
+        };
+        // Special handling for ntfy - use curl with proper syntax
+        if (action.ntfyUrl) {
+            // curl -s -d "message" https://ntfy.sh/topic
+            fullCommand = `curl -s -d "${message.replace(/"/g, '\\"')}" "${action.ntfyUrl}"`;
+        }
+        else {
+            // Command can use $RALPH_MESSAGE env var
+            // Also pass args for backwards compatibility
+            fullCommand = args.length > 0
+                ? `${action.command} ${args.map(a => `"${a.replace(/"/g, '\\"')}"`).join(" ")}`
+                : action.command;
+        }
+        const proc = spawn(fullCommand, [], {
+            stdio: ["ignore", "pipe", "pipe"],
+            shell: true,
+            env,
+        });
+        let stdout = "";
+        let stderr = "";
+        proc.stdout.on("data", (data) => {
+            stdout += data.toString();
+        });
+        proc.stderr.on("data", (data) => {
+            stderr += data.toString();
+        });
+        proc.on("close", (code) => {
+            if (code === 0) {
+                resolve({ success: true, output: stdout.trim() });
+            }
+            else {
+                resolve({
+                    success: false,
+                    output: stdout.trim(),
+                    error: stderr.trim() || `Exit code: ${code}`,
+                });
+            }
+        });
+        proc.on("error", (err) => {
+            resolve({ success: false, output: "", error: err.message });
+        });
+    });
+}
+/**
+ * Process a message from the sandbox.
+ */
+async function processMessage(message, actions, messagesPath, debug) {
+    if (debug) {
+        console.log(`[daemon] Processing: ${message.action} (${message.id})`);
+    }
+    const action = actions[message.action];
+    if (!action) {
+        respondToMessage(messagesPath, message.id, {
+            success: false,
+            error: `Unknown action: ${message.action}. Available: ${Object.keys(actions).join(", ")}`,
+        });
+        return;
+    }
+    const result = await executeAction(action, message.args);
+    respondToMessage(messagesPath, message.id, {
+        success: result.success,
+        output: result.output,
+        error: result.error,
+    });
+    if (debug) {
+        console.log(`[daemon] Responded: ${result.success ? "success" : "failed"}`);
+    }
+}
+/**
+ * Start the daemon - watches for messages from sandbox.
+ */
+async function startDaemon(debug) {
+    // Daemon should not run inside a container
+    if (isRunningInContainer()) {
+        console.error("Error: 'ralph daemon' should run on the host, not inside a container.");
+        console.error("The daemon processes messages from the sandbox.");
+        process.exit(1);
+    }
+    const config = loadConfig();
+    const daemonConfig = config.daemon || {};
+    // Initialize Telegram client if configured
+    await initTelegramClient(config);
+    // Merge default and configured actions
+    const defaultActions = getDefaultActions(config);
+    const configuredActions = daemonConfig.actions || {};
+    const actions = { ...defaultActions, ...configuredActions };
+    const messagesPath = getMessagesPath(false);
+    const ralphDir = getRalphDir();
+    // Initialize messages file with daemon_started message
+    initializeMessages(messagesPath);
+    console.log("Ralph daemon started");
+    console.log(`Messages file: ${messagesPath}`);
+    console.log("");
+    console.log("Available actions:");
+    for (const [name, action] of Object.entries(actions)) {
+        console.log(`  ${name}: ${action.description || action.command}`);
+    }
+    console.log("");
+    console.log("Watching for messages from sandbox...");
+    console.log("Press Ctrl+C to stop.");
+    // Process any pending messages on startup
+    const pending = getPendingMessages(messagesPath, "sandbox");
+    for (const msg of pending) {
+        await processMessage(msg, actions, messagesPath, debug);
+    }
+    // Watch for file changes
+    let processing = false;
+    let watcher = null;
+    const checkMessages = async () => {
+        if (processing)
+            return;
+        processing = true;
+        try {
+            const pending = getPendingMessages(messagesPath, "sandbox");
+            for (const msg of pending) {
+                await processMessage(msg, actions, messagesPath, debug);
+            }
+            // Cleanup old messages periodically
+            cleanupOldMessages(messagesPath, 60000);
+        }
+        catch (err) {
+            if (debug) {
+                console.error(`[daemon] Error processing messages: ${err}`);
+            }
+        }
+        processing = false;
+    };
+    // Watch the .ralph directory for changes
+    if (existsSync(ralphDir)) {
+        watcher = watch(ralphDir, { persistent: true }, (eventType, filename) => {
+            if (filename === "messages.json") {
+                checkMessages();
+            }
+        });
+    }
+    // Also poll periodically as backup (file watching can be unreliable)
+    const pollInterval = setInterval(checkMessages, 1000);
+    // Handle shutdown
+    const shutdown = () => {
+        console.log("\nShutting down daemon...");
+        if (watcher) {
+            watcher.close();
+        }
+        clearInterval(pollInterval);
+        process.exit(0);
+    };
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+}
+/**
+ * Show daemon status.
+ */
+function showStatus() {
+    const messagesPath = getMessagesPath(false);
+    console.log("Ralph Daemon Status");
+    console.log("-".repeat(40));
+    console.log(`Messages file: ${messagesPath}`);
+    console.log(`File exists: ${existsSync(messagesPath) ? "yes" : "no"}`);
+    if (existsSync(messagesPath)) {
+        const messages = readMessages(messagesPath);
+        const pending = messages.filter((m) => m.status === "pending");
+        console.log(`Total messages: ${messages.length}`);
+        console.log(`Pending messages: ${pending.length}`);
+    }
+    console.log("");
+    console.log("To start the daemon: ralph daemon start");
+}
+/**
+ * Main daemon command handler.
+ */
+export async function daemon(args) {
+    const subcommand = args[0];
+    const debug = args.includes("--debug") || args.includes("-d");
+    // Show help
+    if (subcommand === "help" || subcommand === "--help" || subcommand === "-h" || !subcommand) {
+        console.log(`
+ralph daemon - Host daemon for sandbox-to-host communication
+
+USAGE:
+  ralph daemon start [--debug]  Start the daemon (run on host, not in container)
+  ralph daemon status           Show daemon status
+  ralph daemon help             Show this help message
+
+DESCRIPTION:
+  The daemon runs on the host machine and watches the .ralph/messages.json
+  file for messages from the sandboxed container. When the sandbox sends
+  a message, the daemon processes it and writes a response.
+
+  This file-based approach works on all platforms (macOS, Linux, Windows)
+  and allows other tools to also interact with the message queue.
+
+CONFIGURATION:
+  Configure notifications in .ralph/config.json:
+
+  Using ntfy (recommended - no install needed, uses curl):
+  {
+    "notifications": {
+      "provider": "ntfy",
+      "ntfy": {
+        "topic": "my-ralph-notifications",
+        "server": "https://ntfy.sh"
+      }
+    }
+  }
+
+  Using a custom command:
+  {
+    "notifications": {
+      "provider": "command",
+      "command": "notify-send Ralph"
+    }
+  }
+
+  Custom daemon actions:
+  {
+    "daemon": {
+      "actions": {
+        "custom-action": {
+          "command": "/path/to/script.sh",
+          "description": "Run custom script"
+        }
+      }
+    }
+  }
+
+DEFAULT ACTIONS:
+  ping         Health check - responds with 'pong'
+  notify       Send notification (uses notifications config)
+  chat_status  Get PRD status as JSON
+  chat_add     Add a new task to the PRD
+
+SANDBOX USAGE:
+  From inside the container, use 'ralph notify' to send messages:
+
+  ralph notify "Task completed!"
+  ralph notify --action ping
+
+MESSAGE FORMAT:
+  The messages.json file contains an array of messages:
+
+  [
+    {
+      "id": "uuid",
+      "from": "sandbox",
+      "action": "notify",
+      "args": ["Hello!"],
+      "timestamp": 1234567890,
+      "status": "pending"
+    }
+  ]
+
+  When the daemon processes a message, it updates the status and adds a response:
+
+  {
+    "id": "uuid",
+    "from": "sandbox",
+    "action": "notify",
+    "args": ["Hello!"],
+    "timestamp": 1234567890,
+    "status": "done",
+    "response": {
+      "success": true,
+      "output": "..."
+    }
+  }
+
+  Other tools can read/write to this file for integration.
+
+EXAMPLES:
+  # Terminal 1: Start daemon on host
+  ralph daemon start
+
+  # Terminal 2: Run container
+  ralph docker run
+
+  # Inside container: Send notification
+  ralph notify "PRD complete!"
+`);
+        return;
+    }
+    switch (subcommand) {
+        case "start":
+            await startDaemon(debug);
+            break;
+        case "status":
+            showStatus();
+            break;
+        case "stop":
+            console.log("The file-based daemon doesn't require stopping.");
+            console.log("Just press Ctrl+C in the terminal where it's running.");
+            break;
+        default:
+            console.error(`Unknown subcommand: ${subcommand}`);
+            console.error("Run 'ralph daemon help' for usage information.");
+            process.exit(1);
+    }
+}

package/dist/commands/docker.js

@@ -1,10 +1,12 @@
-import { existsSync, writeFileSync, readFileSync, mkdirSync, chmodSync } from "fs";
+import { existsSync, writeFileSync, readFileSync, mkdirSync, chmodSync, openSync } from "fs";
 import { join, basename } from "path";
 import { spawn } from "child_process";
 import { createHash } from "crypto";
 import { loadConfig, getRalphDir } from "../utils/config.js";
 import { promptConfirm } from "../utils/prompt.js";
 import { getLanguagesJson, getCliProvidersJson } from "../templates/prompts.js";
+// Track background processes for cleanup
+const backgroundProcesses = [];
 const DOCKER_DIR = "docker";
 const CONFIG_HASH_FILE = ".config-hash";
 // Compute hash of docker-relevant config fields
@@ -397,6 +399,17 @@ function generateDockerCompose(imageName, dockerConfig) {
         commandSection = `    # Uncomment to enable firewall sandboxing:
     # command: bash -c "sudo /usr/local/bin/init-firewall.sh && zsh"\n`;
     }
+    // Build restart policy section
+    // Priority: restartCount (on-failure with max retries) > autoStart (unless-stopped)
+    let restartSection = '';
+    if (dockerConfig?.restartCount !== undefined && dockerConfig.restartCount > 0) {
+        // Use on-failure policy with max retry count
+        restartSection = `    restart: on-failure:${dockerConfig.restartCount}\n`;
+    }
+    else if (dockerConfig?.autoStart) {
+        // Use unless-stopped for auto-restart on daemon start
+        restartSection = '    restart: unless-stopped\n';
+    }
     return `# Ralph CLI Docker Compose
 # Generated by ralph-cli
 
@@ -413,7 +426,7 @@ ${environmentSection}    working_dir: /workspace
     tty: true
     cap_add:
       - NET_ADMIN  # Required for firewall
-${streamJsonNote}${commandSection}
+${restartSection}${streamJsonNote}${commandSection}
 volumes:
   ${imageName}-history:
 `;
@@ -681,7 +694,64 @@ function getCliProviderConfig(cliProvider) {
         modelConfig: provider.modelConfig,
     };
 }
-async function runContainer(ralphDir, imageName, language, javaVersion, cliProvider, dockerConfig, claudeConfig) {
+/**
+ * Start background services (daemon, chat) if configured.
+ * Returns cleanup function to stop services.
+ */
+function startBackgroundServices(config) {
+    const services = [];
+    const ralphDir = getRalphDir();
+    const logFiles = [];
+    // Start daemon if notifications are configured
+    if (config.notifications?.provider) {
+        const logPath = join(ralphDir, "daemon.log");
+        const logFd = openSync(logPath, "w");
+        logFiles.push(logFd);
+        console.log("Starting daemon (notifications configured)...");
+        const daemon = spawn("ralph", ["daemon", "start"], {
+            stdio: ["ignore", logFd, logFd],
+            detached: true,
+        });
+        daemon.unref();
+        backgroundProcesses.push(daemon);
+        services.push("daemon");
+    }
+    // Start chat if telegram is configured and not explicitly disabled
+    const telegramEnabled = config.chat?.telegram?.botToken &&
+        config.chat.telegram.enabled !== false;
+    if (telegramEnabled) {
+        const logPath = join(ralphDir, "chat.log");
+        const logFd = openSync(logPath, "w");
+        logFiles.push(logFd);
+        console.log("Starting chat client (chat configured)...");
+        const chat = spawn("ralph", ["chat", "start"], {
+            stdio: ["ignore", logFd, logFd],
+            detached: true,
+        });
+        chat.unref();
+        backgroundProcesses.push(chat);
+        services.push("chat");
+    }
+    if (services.length > 0) {
+        console.log(`Background services started: ${services.join(", ")}`);
+        console.log(`Logs: .ralph/daemon.log, .ralph/chat.log`);
+        console.log(`Check status: tail -f .ralph/*.log\n`);
+    }
+    // Return cleanup function
+    return () => {
+        for (const proc of backgroundProcesses) {
+            try {
+                if (proc.pid) {
+                    process.kill(-proc.pid, "SIGTERM");
+                }
+            }
+            catch {
+                // Process may already be dead
+            }
+        }
+    };
+}
+async function runContainer(ralphDir, imageName, language, javaVersion, cliProvider, dockerConfig, claudeConfig, fullConfig) {
     const dockerDir = join(ralphDir, DOCKER_DIR);
     const dockerfileExists = existsSync(join(dockerDir, "Dockerfile"));
     const hasImage = await imageExists(imageName);
@@ -757,6 +827,11 @@ async function runContainer(ralphDir, imageName, language, javaVersion, cliProvi
     }
     console.log("Set them in docker-compose.yml or export before running.");
     console.log("");
+    // Start background services if configured
+    let cleanupServices = () => { };
+    if (fullConfig) {
+        cleanupServices = startBackgroundServices(fullConfig);
+    }
     return new Promise((resolve, reject) => {
         // Use -p to set unique project name per ralph project
         const proc = spawn("docker", ["compose", "-p", imageName, "run", "--rm", "ralph"], {
@@ -764,6 +839,8 @@ async function runContainer(ralphDir, imageName, language, javaVersion, cliProvi
             stdio: "inherit",
         });
         proc.on("close", (code) => {
+            // Clean up background services
+            cleanupServices();
             if (code === 0) {
                 resolve();
             }
@@ -772,6 +849,7 @@ async function runContainer(ralphDir, imageName, language, javaVersion, cliProvi
             }
         });
         proc.on("error", (err) => {
+            cleanupServices();
             reject(new Error(`Failed to run docker: ${err.message}`));
         });
     });
@@ -1046,7 +1124,7 @@ INSTALLING PACKAGES (works with Docker & Podman):
             await buildImage(ralphDir);
             break;
         case "run":
-            await runContainer(ralphDir, imageName, config.language, config.javaVersion, config.cliProvider, config.docker, config.claude);
+            await runContainer(ralphDir, imageName, config.language, config.javaVersion, config.cliProvider, config.docker, config.claude, config);
             break;
         case "clean":
             await cleanImage(imageName, ralphDir);

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

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