ralph-cli-sandboxed 0.2.9 → 0.4.0

package/dist/commands/fix-config.js

@@ -0,0 +1,388 @@
+import { existsSync, readFileSync, writeFileSync, copyFileSync } from "fs";
+import { getPaths } from "../utils/config.js";
+import { promptConfirm } from "../utils/prompt.js";
+import { getLanguages, getCliProviders } from "../templates/prompts.js";
+/**
+ * Configuration sections that can be individually validated and recovered.
+ */
+const CONFIG_SECTIONS = [
+    "language",
+    "checkCommand",
+    "testCommand",
+    "imageName",
+    "cli",
+    "cliProvider",
+    "notifyCommand",
+    "notifications",
+    "technologies",
+    "javaVersion",
+    "docker",
+    "claude",
+    "chat",
+    "daemon",
+];
+/**
+ * Attempts to parse JSON, returning the error position if parsing fails.
+ */
+function parseJsonWithError(content) {
+    try {
+        return { data: JSON.parse(content) };
+    }
+    catch (err) {
+        if (err instanceof SyntaxError) {
+            const errorMsg = err.message;
+            // Extract position from error message (e.g., "at position 123" or "at line 5 column 10")
+            const posMatch = errorMsg.match(/at position (\d+)/);
+            const lineColMatch = errorMsg.match(/at line (\d+) column (\d+)/);
+            if (lineColMatch) {
+                return {
+                    error: errorMsg,
+                    line: parseInt(lineColMatch[1], 10),
+                    column: parseInt(lineColMatch[2], 10),
+                };
+            }
+            else if (posMatch) {
+                const position = parseInt(posMatch[1], 10);
+                const lines = content.substring(0, position).split("\n");
+                return {
+                    error: errorMsg,
+                    line: lines.length,
+                    column: lines[lines.length - 1].length + 1,
+                };
+            }
+            return { error: errorMsg };
+        }
+        return { error: String(err) };
+    }
+}
+/**
+ * Generates default config values (matching ralph init defaults).
+ */
+function getDefaultConfig() {
+    const LANGUAGES = getLanguages();
+    const CLI_PROVIDERS = getCliProviders();
+    const defaultLanguage = "node";
+    const defaultProvider = CLI_PROVIDERS["claude"];
+    const langConfig = LANGUAGES[defaultLanguage];
+    return {
+        language: defaultLanguage,
+        checkCommand: langConfig.checkCommand,
+        testCommand: langConfig.testCommand,
+        imageName: "ralph-project",
+        cli: {
+            command: defaultProvider.command,
+            args: defaultProvider.defaultArgs,
+            yoloArgs: defaultProvider.yoloArgs.length > 0 ? defaultProvider.yoloArgs : undefined,
+            promptArgs: defaultProvider.promptArgs ?? [],
+        },
+        cliProvider: "claude",
+        notifyCommand: "",
+        technologies: [],
+        docker: {
+            ports: [],
+            volumes: [],
+            environment: {},
+            git: {
+                name: "",
+                email: "",
+            },
+            packages: [],
+            buildCommands: {
+                root: [],
+                node: [],
+            },
+            startCommand: "",
+            asciinema: {
+                enabled: false,
+                autoRecord: false,
+                outputDir: ".recordings",
+                streamJson: {
+                    enabled: false,
+                    saveRawJson: true,
+                },
+            },
+            firewall: {
+                allowedDomains: [],
+            },
+            autoStart: false,
+            restartCount: 0,
+        },
+        claude: {
+            mcpServers: {},
+            skills: [],
+        },
+        chat: {
+            enabled: false,
+            provider: "telegram",
+            telegram: {
+                botToken: "",
+                allowedChatIds: [],
+            },
+        },
+        daemon: {
+            actions: {},
+            events: {},
+        },
+    };
+}
+/**
+ * Validates a specific section of the config.
+ */
+function validateSection(section, value) {
+    if (value === undefined || value === null) {
+        return false;
+    }
+    switch (section) {
+        case "language":
+        case "checkCommand":
+        case "testCommand":
+        case "imageName":
+        case "cliProvider":
+        case "notifyCommand":
+            return typeof value === "string";
+        case "technologies":
+            return Array.isArray(value) && value.every((item) => typeof item === "string");
+        case "javaVersion":
+            return value === null || typeof value === "number";
+        case "cli":
+            if (typeof value !== "object" || value === null)
+                return false;
+            const cli = value;
+            return typeof cli.command === "string";
+        case "notifications":
+            if (typeof value !== "object" || value === null)
+                return false;
+            const notif = value;
+            return typeof notif.provider === "string";
+        case "docker":
+        case "claude":
+        case "chat":
+        case "daemon":
+            return typeof value === "object" && value !== null;
+        default:
+            return true;
+    }
+}
+/**
+ * Attempts to extract a value from potentially corrupt JSON using regex.
+ * This is a best-effort approach for partially corrupt files.
+ */
+function extractSectionFromCorrupt(content, section) {
+    // Try to find the section in the raw content
+    const patterns = {
+        language: /"language"\s*:\s*"([^"]+)"/,
+        checkCommand: /"checkCommand"\s*:\s*"([^"]+)"/,
+        testCommand: /"testCommand"\s*:\s*"([^"]+)"/,
+        imageName: /"imageName"\s*:\s*"([^"]+)"/,
+        cliProvider: /"cliProvider"\s*:\s*"([^"]+)"/,
+        notifyCommand: /"notifyCommand"\s*:\s*"([^"]*)"/,
+    };
+    const pattern = patterns[section];
+    if (pattern) {
+        const match = content.match(pattern);
+        if (match) {
+            return match[1];
+        }
+    }
+    return undefined;
+}
+/**
+ * Attempts to recover valid sections from a corrupt config.
+ */
+function recoverSections(corruptContent, parsedPartial) {
+    const defaultConfig = getDefaultConfig();
+    const recoveredConfig = {};
+    const result = {
+        recovered: [],
+        reset: [],
+        errors: [],
+    };
+    for (const section of CONFIG_SECTIONS) {
+        let value = undefined;
+        let source = "default";
+        // First, try to get from parsed partial (if JSON was partially valid)
+        if (parsedPartial && section in parsedPartial) {
+            value = parsedPartial[section];
+            source = "parsed";
+        }
+        // If not found or invalid, try regex extraction for simple string fields
+        if ((value === undefined || !validateSection(section, value)) && typeof corruptContent === "string") {
+            const extracted = extractSectionFromCorrupt(corruptContent, section);
+            if (extracted !== undefined && validateSection(section, extracted)) {
+                value = extracted;
+                source = "extracted";
+            }
+        }
+        // Validate the value
+        if (validateSection(section, value)) {
+            recoveredConfig[section] = value;
+            result.recovered.push(section);
+        }
+        else {
+            // Use default value
+            recoveredConfig[section] = defaultConfig[section];
+            result.reset.push(section);
+        }
+    }
+    return result;
+}
+/**
+ * Creates a backup of the config file.
+ */
+function createBackup(configPath) {
+    const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+    const backupPath = configPath.replace("config.json", `config.json.backup.${timestamp}`);
+    copyFileSync(configPath, backupPath);
+    return backupPath;
+}
+/**
+ * Merges recovered sections into a valid config object.
+ */
+function buildRecoveredConfig(corruptContent, parsedPartial) {
+    const defaultConfig = getDefaultConfig();
+    const result = {
+        recovered: [],
+        reset: [],
+        errors: [],
+    };
+    const config = {};
+    for (const section of CONFIG_SECTIONS) {
+        let value = undefined;
+        // First, try to get from parsed partial
+        if (parsedPartial && section in parsedPartial) {
+            value = parsedPartial[section];
+        }
+        // If not found or invalid, try regex extraction
+        if (value === undefined || !validateSection(section, value)) {
+            const extracted = extractSectionFromCorrupt(corruptContent, section);
+            if (extracted !== undefined && validateSection(section, extracted)) {
+                value = extracted;
+            }
+        }
+        // Validate and assign
+        if (validateSection(section, value)) {
+            config[section] = value;
+            result.recovered.push(section);
+        }
+        else {
+            config[section] = defaultConfig[section];
+            result.reset.push(section);
+        }
+    }
+    return { config: config, result };
+}
+/**
+ * Main fix-config command handler.
+ */
+export async function fixConfig(args) {
+    const verifyOnly = args.includes("--verify") || args.includes("-v");
+    const skipPrompt = args.includes("-y") || args.includes("--yes");
+    const paths = getPaths();
+    const configPath = paths.config;
+    // Check if config file exists
+    if (!existsSync(configPath)) {
+        console.error("Error: .ralph/config.json not found. Run 'ralph init' first.");
+        process.exit(1);
+    }
+    console.log("Checking config.json...\n");
+    // Read the raw content
+    const rawContent = readFileSync(configPath, "utf-8");
+    // Attempt to parse the JSON
+    const parseResult = parseJsonWithError(rawContent);
+    if (parseResult.data) {
+        // JSON is syntactically valid
+        const config = parseResult.data;
+        // Validate required fields
+        const missingFields = [];
+        if (typeof config.language !== "string")
+            missingFields.push("language");
+        if (typeof config.checkCommand !== "string")
+            missingFields.push("checkCommand");
+        if (typeof config.testCommand !== "string")
+            missingFields.push("testCommand");
+        if (missingFields.length === 0) {
+            console.log("\x1b[32m✓ config.json is valid.\x1b[0m");
+            return;
+        }
+        console.log("\x1b[33m⚠ config.json is missing required fields:\x1b[0m");
+        missingFields.forEach((field) => console.log(`  - ${field}`));
+        if (verifyOnly) {
+            process.exit(1);
+        }
+        // Offer to fix missing fields
+        if (!skipPrompt) {
+            const confirm = await promptConfirm("\nFix missing fields with defaults?");
+            if (!confirm) {
+                console.log("Aborted.");
+                return;
+            }
+        }
+        // Create backup
+        const backupPath = createBackup(configPath);
+        console.log(`\nCreated backup: ${backupPath}`);
+        // Merge with defaults
+        const defaultConfig = getDefaultConfig();
+        const fixedConfig = { ...defaultConfig, ...config };
+        // Ensure required fields exist
+        for (const field of missingFields) {
+            fixedConfig[field] = defaultConfig[field];
+        }
+        writeFileSync(configPath, JSON.stringify(fixedConfig, null, 2) + "\n");
+        console.log("\n\x1b[32m✓ config.json repaired.\x1b[0m");
+        console.log(`  Added defaults for: ${missingFields.join(", ")}`);
+        return;
+    }
+    // JSON parsing failed
+    console.log("\x1b[31m✗ config.json contains invalid JSON.\x1b[0m");
+    console.log(`  Error: ${parseResult.error}`);
+    if (parseResult.line) {
+        console.log(`  Location: line ${parseResult.line}, column ${parseResult.column || "?"}`);
+    }
+    if (verifyOnly) {
+        process.exit(1);
+    }
+    // Attempt recovery
+    console.log("\nAttempting to recover valid sections...\n");
+    // Try to parse partially (some JSON parsers are more lenient)
+    let parsedPartial = null;
+    try {
+        // Try JSON5-style parsing by removing trailing commas and comments
+        const cleaned = rawContent
+            .replace(/,\s*([\]}])/g, "$1") // Remove trailing commas
+            .replace(/\/\/.*$/gm, "") // Remove single-line comments
+            .replace(/\/\*[\s\S]*?\*\//g, ""); // Remove multi-line comments
+        parsedPartial = JSON.parse(cleaned);
+    }
+    catch {
+        // Partial parsing failed, continue with regex extraction
+    }
+    const { config: recoveredConfig, result } = buildRecoveredConfig(rawContent, parsedPartial);
+    // Report results
+    console.log("Recovery analysis:");
+    if (result.recovered.length > 0) {
+        console.log(`\x1b[32m  Recoverable sections (${result.recovered.length}):\x1b[0m`);
+        result.recovered.forEach((section) => console.log(`    ✓ ${section}`));
+    }
+    if (result.reset.length > 0) {
+        console.log(`\x1b[33m  Reset to defaults (${result.reset.length}):\x1b[0m`);
+        result.reset.forEach((section) => console.log(`    ⚠ ${section}`));
+    }
+    // Confirm before applying
+    if (!skipPrompt) {
+        console.log();
+        const confirm = await promptConfirm("Apply these fixes?");
+        if (!confirm) {
+            console.log("Aborted.");
+            return;
+        }
+    }
+    // Create backup of corrupt file
+    const backupPath = createBackup(configPath);
+    console.log(`\nCreated backup: ${backupPath}`);
+    // Write the recovered config
+    writeFileSync(configPath, JSON.stringify(recoveredConfig, null, 2) + "\n");
+    console.log("\n\x1b[32m✓ config.json repaired.\x1b[0m");
+    console.log(`  Recovered: ${result.recovered.length} sections`);
+    console.log(`  Reset to defaults: ${result.reset.length} sections`);
+    console.log(`  Original backup: ${backupPath}`);
+}

package/dist/commands/help.js

@@ -14,8 +14,13 @@ COMMANDS:
   toggle <n>        Toggle passes status for entry n
   clean             Remove all passing entries from the PRD
   fix-prd [opts]    Validate and recover corrupted PRD file
+  fix-config [opts] Validate and recover corrupted config.json
   prompt [opts]     Display resolved prompt (for testing in Claude Code)
   docker <sub>      Manage Docker sandbox environment
+  daemon <sub>      Host daemon for sandbox-to-host communication
+  notify [msg]      Send notification to host from sandbox
+  action [name]     Execute host actions from config.json
+  chat <sub>        Chat client integration (Telegram, etc.)
   help              Show this help message
 
   prd <subcommand>  (Alias) Manage PRD entries - same as add/list/status/toggle/clean
@@ -47,6 +52,10 @@ FIX-PRD OPTIONS:
   <backup-file>              Restore PRD from a specific backup file
   --verify, -v               Only verify format, don't attempt to fix
 
+FIX-CONFIG OPTIONS:
+  --verify, -v               Only verify format, don't attempt to fix
+  -y, --yes                  Skip confirmation prompt, apply fixes automatically
+
 DOCKER SUBCOMMANDS:
   docker init       Generate Dockerfile and scripts
   docker build      Build image (always fetches latest Claude Code)
@@ -54,6 +63,29 @@ DOCKER SUBCOMMANDS:
   docker clean      Remove Docker image and associated resources
   docker help       Show docker help message
 
+DAEMON SUBCOMMANDS:
+  daemon start      Start daemon on host (listens for sandbox requests)
+  daemon stop       Stop the daemon
+  daemon status     Show daemon status
+  daemon help       Show daemon help message
+
+CHAT SUBCOMMANDS:
+  chat start        Start chat daemon (Telegram bot)
+  chat status       Show chat configuration status
+  chat test [id]    Test connection by sending a message
+  chat help         Show chat help message
+
+NOTIFY OPTIONS:
+  [message]              Message to send as notification
+  --action, -a <name>    Execute specific daemon action (default: notify)
+  --debug, -d            Show debug output
+
+ACTION OPTIONS:
+  [name]                 Name of the action to execute
+  [args...]              Arguments to pass to the action command
+  --list, -l             List all configured actions
+  --debug, -d            Show debug output
+
 EXAMPLES:
   ralph init                 # Initialize ralph (interactive CLI, language, tech selection)
   ralph init -y              # Initialize with defaults (Claude + Node.js, no prompts)
@@ -75,10 +107,19 @@ EXAMPLES:
   ralph fix-prd              # Validate/recover corrupted PRD file
   ralph fix-prd --verify     # Check PRD format without fixing
   ralph fix-prd backup.prd.2024-01-15.json  # Restore from specific backup
+  ralph fix-config           # Validate/recover corrupted config.json
+  ralph fix-config --verify  # Check config format without fixing
+  ralph fix-config -y        # Auto-fix without prompts
   ralph prompt               # Display resolved prompt
   ralph docker init          # Generate Dockerfile for sandboxed env
   ralph docker build         # Build Docker image
   ralph docker run           # Run container (auto-init/build if needed)
+  ralph daemon start         # Start daemon on host (in separate terminal)
+  ralph notify "Task done!"  # Send notification from sandbox to host
+  ralph chat start           # Start Telegram chat daemon
+  ralph chat test 123456     # Test chat connection
+  ralph action --list        # List available host actions
+  ralph action build         # Execute 'build' action on host
 
 CONFIGURATION:
   After running 'ralph init', you'll have:
@@ -110,6 +151,45 @@ CLI CONFIGURATION:
     - custom: Configure your own CLI
 
   Customize 'command', 'args', and 'yoloArgs' for other AI CLIs.
+
+DAEMON CONFIGURATION:
+  The daemon allows sandbox-to-host communication without external network.
+  Configure custom actions in .ralph/config.json:
+  {
+    "notifyCommand": "ntfy pub mytopic",
+    "daemon": {
+      "actions": {
+        "build": {
+          "command": "./scripts/build.sh",
+          "description": "Run build on host"
+        }
+      }
+    }
+  }
+
+  Usage flow:
+  1. Start daemon on host:  ralph daemon start
+  2. Run sandbox:           ralph docker run
+  3. From sandbox, notify:  ralph notify "Task complete!"
+
+CHAT CONFIGURATION:
+  Enable Telegram chat integration to control ralph from your phone:
+  {
+    "chat": {
+      "enabled": true,
+      "provider": "telegram",
+      "telegram": {
+        "botToken": "YOUR_BOT_TOKEN",
+        "allowedChatIds": ["123456789"]
+      }
+    }
+  }
+
+  Setup:
+  1. Create bot with @BotFather on Telegram
+  2. Add bot token to config.json
+  3. Start chat daemon: ralph chat start
+  4. Send commands to your bot: abc run, abc status, abc add <task>
 `;
 export function help(_args) {
     console.log(HELP_TEXT.trim());

package/dist/commands/init.js

@@ -1,7 +1,8 @@
-import { existsSync, writeFileSync, mkdirSync, copyFileSync } from "fs";
+import { existsSync, writeFileSync, mkdirSync, copyFileSync, chmodSync } from "fs";
 import { join, basename, dirname } from "path";
 import { fileURLToPath } from "url";
 import { getLanguages, generatePromptTemplate, DEFAULT_PRD, DEFAULT_PROGRESS, getCliProviders, getSkillsForLanguage } from "../templates/prompts.js";
+import { generateGenXcodeScript, hasSwiftUI, hasFastlane, generateFastfile, generateAppfile, generateFastlaneReadmeSection } from "../templates/macos-scripts.js";
 import { promptSelectWithArrows, promptConfirm, promptInput, promptMultiSelectWithArrows } from "../utils/prompt.js";
 import { dockerInit } from "./docker.js";
 // Get package root directory (works for both dev and installed package)
@@ -155,6 +156,37 @@ export async function init(args) {
     // Generate image name from directory name
     const projectName = basename(cwd).toLowerCase().replace(/[^a-z0-9-]/g, "-");
     const imageName = `ralph-${projectName}`;
+    // Generate macOS development actions for Swift + SwiftUI projects
+    const macOsActions = {};
+    if (selectedKey === "swift" && hasSwiftUI(selectedTechnologies)) {
+        macOsActions.gen_xcode = {
+            command: "./scripts/gen_xcode.sh",
+            description: "Generate Xcode project from Swift package",
+        };
+        macOsActions.build = {
+            command: "xcodebuild -project *.xcodeproj -scheme * -configuration Debug build",
+            description: "Build the Xcode project in Debug mode",
+        };
+        macOsActions.test = {
+            command: "xcodebuild -project *.xcodeproj -scheme * test",
+            description: "Run tests via xcodebuild",
+        };
+        // Add Fastlane actions if Fastlane technology is selected
+        if (hasFastlane(selectedTechnologies)) {
+            macOsActions.fastlane_init = {
+                command: "cd scripts/fastlane && fastlane init",
+                description: "Initialize Fastlane credentials (interactive)",
+            };
+            macOsActions.fastlane_beta = {
+                command: "cd scripts/fastlane && fastlane beta",
+                description: "Deploy beta build via Fastlane",
+            };
+            macOsActions.fastlane_release = {
+                command: "cd scripts/fastlane && fastlane release",
+                description: "Deploy release build via Fastlane",
+            };
+        }
+    }
     // Write config file with all available options (defaults or empty values)
     const configData = {
         // Required fields
@@ -196,12 +228,35 @@ export async function init(args) {
             firewall: {
                 allowedDomains: [],
             },
+            autoStart: false,
+            restartCount: 0,
         },
         // Claude-specific configuration (MCP servers and skills)
         claude: {
             mcpServers: {},
             skills: selectedSkills,
         },
+        // Chat client configuration (e.g., Telegram)
+        chat: {
+            enabled: false,
+            provider: "telegram",
+            telegram: {
+                botToken: "",
+                allowedChatIds: [],
+            },
+        },
+        // Daemon configuration for sandbox-to-host communication
+        daemon: {
+            actions: macOsActions,
+            // Event handlers - each event can trigger multiple daemon actions
+            // Available events: task_complete, ralph_complete, iteration_complete, error
+            events: {
+            // Example: notify after each task completes
+            // task_complete: [{ action: "notify", message: "Task complete: {{task}}" }],
+            // Example: notify when ralph finishes all work
+            // ralph_complete: [{ action: "notify", message: "Ralph finished!" }],
+            },
+        },
     };
     const configPath = join(ralphDir, CONFIG_FILE);
     writeFileSync(configPath, JSON.stringify(configData, null, 2) + "\n");
@@ -241,6 +296,85 @@ export async function init(args) {
     else {
         console.log(`Skipped ${RALPH_DIR}/${PROGRESS_FILE} (already exists)`);
     }
+    // Create .gitignore if not exists (protects secrets like API tokens)
+    const gitignorePath = join(ralphDir, ".gitignore");
+    if (!existsSync(gitignorePath)) {
+        const gitignoreContent = `# Ralph CLI - Ignore sensitive and runtime files
+# config.json may contain API tokens (Telegram, etc.)
+config.json
+
+# Runtime state files
+messages.json
+chat-state.json
+
+# Service logs
+daemon.log
+chat.log
+
+# Docker build artifacts
+docker/.config-hash
+`;
+        writeFileSync(gitignorePath, gitignoreContent);
+        console.log(`Created ${RALPH_DIR}/.gitignore`);
+    }
+    else {
+        console.log(`Skipped ${RALPH_DIR}/.gitignore (already exists)`);
+    }
+    // Generate macOS/Swift development scripts if Swift + SwiftUI selected
+    if (selectedKey === "swift" && hasSwiftUI(selectedTechnologies)) {
+        const scriptsDir = join(cwd, "scripts");
+        const genXcodePath = join(scriptsDir, "gen_xcode.sh");
+        if (!existsSync(scriptsDir)) {
+            mkdirSync(scriptsDir, { recursive: true });
+            console.log("Created scripts/");
+        }
+        // Use a clean project name (PascalCase) for the Swift project
+        const swiftProjectName = basename(cwd)
+            .replace(/[^a-zA-Z0-9]+/g, " ")
+            .split(" ")
+            .map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+            .join("") || "App";
+        if (!existsSync(genXcodePath)) {
+            writeFileSync(genXcodePath, generateGenXcodeScript(swiftProjectName));
+            chmodSync(genXcodePath, 0o755);
+            console.log("Created scripts/gen_xcode.sh");
+        }
+        else {
+            console.log("Skipped scripts/gen_xcode.sh (already exists)");
+        }
+        // Generate Fastlane configuration if Fastlane technology is selected
+        if (hasFastlane(selectedTechnologies)) {
+            const fastlaneDir = join(scriptsDir, "fastlane");
+            const fastfilePath = join(fastlaneDir, "Fastfile");
+            const appfilePath = join(fastlaneDir, "Appfile");
+            const readmePath = join(fastlaneDir, "README.md");
+            if (!existsSync(fastlaneDir)) {
+                mkdirSync(fastlaneDir, { recursive: true });
+                console.log("Created scripts/fastlane/");
+            }
+            if (!existsSync(fastfilePath)) {
+                writeFileSync(fastfilePath, generateFastfile(swiftProjectName));
+                console.log("Created scripts/fastlane/Fastfile");
+            }
+            else {
+                console.log("Skipped scripts/fastlane/Fastfile (already exists)");
+            }
+            if (!existsSync(appfilePath)) {
+                writeFileSync(appfilePath, generateAppfile(swiftProjectName));
+                console.log("Created scripts/fastlane/Appfile");
+            }
+            else {
+                console.log("Skipped scripts/fastlane/Appfile (already exists)");
+            }
+            if (!existsSync(readmePath)) {
+                writeFileSync(readmePath, generateFastlaneReadmeSection(swiftProjectName));
+                console.log("Created scripts/fastlane/README.md");
+            }
+            else {
+                console.log("Skipped scripts/fastlane/README.md (already exists)");
+            }
+        }
+    }
     // Copy PRD guide file from package if not exists
     const prdGuidePath = join(ralphDir, PRD_GUIDE_FILE);
     if (!existsSync(prdGuidePath)) {

package/dist/commands/listen.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Listen command - runs in sandbox to process commands from host.
+ * This enables Telegram/chat commands to execute inside the container.
+ */
+/**
+ * Main listen command handler.
+ */
+export declare function listen(args: string[]): Promise<void>;