ralph-cli-sandboxed 0.3.0 → 0.4.0

package/dist/tui/hooks/useTerminalSize.js

@@ -0,0 +1,48 @@
+import { useState, useEffect } from "react";
+import { useStdout } from "ink";
+/**
+ * Default terminal size (standard VT100 terminal dimensions).
+ */
+export const DEFAULT_TERMINAL_SIZE = {
+    columns: 80,
+    rows: 24,
+};
+/**
+ * Minimum terminal size for the config editor.
+ */
+export const MIN_TERMINAL_SIZE = {
+    columns: 60,
+    rows: 16,
+};
+/**
+ * Hook that returns the current terminal size and updates on resize.
+ * Falls back to default dimensions if terminal size cannot be determined.
+ */
+export function useTerminalSize() {
+    const { stdout } = useStdout();
+    const getSize = () => {
+        if (stdout && typeof stdout.columns === "number" && typeof stdout.rows === "number") {
+            return {
+                columns: Math.max(stdout.columns, MIN_TERMINAL_SIZE.columns),
+                rows: Math.max(stdout.rows, MIN_TERMINAL_SIZE.rows),
+            };
+        }
+        return DEFAULT_TERMINAL_SIZE;
+    };
+    const [size, setSize] = useState(getSize);
+    useEffect(() => {
+        const handleResize = () => {
+            setSize(getSize());
+        };
+        // Listen for terminal resize events
+        if (stdout && typeof stdout.on === "function") {
+            stdout.on("resize", handleResize);
+            return () => {
+                stdout.off("resize", handleResize);
+            };
+        }
+        return undefined;
+    }, [stdout]);
+    return size;
+}
+export default useTerminalSize;

package/dist/tui/utils/presets.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Configuration presets for the config editor.
+ * Provides quick setup templates for common integrations.
+ */
+import type { RalphConfig } from "../../utils/config.js";
+/**
+ * A preset defines default values for a specific integration.
+ */
+export interface ConfigPreset {
+    id: string;
+    name: string;
+    description: string;
+    /** Category this preset belongs to (e.g., "chat", "notifications") */
+    category: "chat" | "notifications";
+    /** Fields to apply from this preset (dot-notation paths to values) */
+    fields: Record<string, unknown>;
+}
+/**
+ * Chat provider presets for quick setup.
+ */
+export declare const CHAT_PRESETS: ConfigPreset[];
+/**
+ * Notification provider presets for quick setup.
+ */
+export declare const NOTIFICATION_PRESETS: ConfigPreset[];
+/**
+ * All available presets grouped by category.
+ */
+export declare const ALL_PRESETS: ConfigPreset[];
+/**
+ * Get presets for a specific category.
+ */
+export declare function getPresetsForCategory(category: "chat" | "notifications"): ConfigPreset[];
+/**
+ * Get presets available for a specific config section.
+ * Maps section IDs to preset categories.
+ */
+export declare function getPresetsForSection(sectionId: string): ConfigPreset[];
+/**
+ * Check if a section has available presets.
+ */
+export declare function sectionHasPresets(sectionId: string): boolean;
+/**
+ * Apply a preset to a config object (immutably).
+ * Returns a new config with the preset fields applied.
+ */
+export declare function applyPreset(config: RalphConfig, preset: ConfigPreset): RalphConfig;
+/**
+ * Detect if a preset is currently active based on config values.
+ * Returns the preset ID if detected, or null if no preset matches.
+ */
+export declare function detectActivePreset(config: RalphConfig, sectionId: string): string | null;

package/dist/tui/utils/presets.js

@@ -0,0 +1,191 @@
+/**
+ * Configuration presets for the config editor.
+ * Provides quick setup templates for common integrations.
+ */
+/**
+ * Chat provider presets for quick setup.
+ */
+export const CHAT_PRESETS = [
+    {
+        id: "telegram",
+        name: "Telegram",
+        description: "Telegram Bot API for chat control",
+        category: "chat",
+        fields: {
+            "chat.enabled": true,
+            "chat.provider": "telegram",
+            "chat.telegram": {
+                enabled: true,
+                botToken: "",
+                allowedChatIds: [],
+            },
+        },
+    },
+    {
+        id: "slack",
+        name: "Slack",
+        description: "Slack App for chat control (coming soon)",
+        category: "chat",
+        fields: {
+            "chat.enabled": true,
+            "chat.provider": "slack",
+        },
+    },
+    {
+        id: "discord",
+        name: "Discord",
+        description: "Discord Bot for chat control (coming soon)",
+        category: "chat",
+        fields: {
+            "chat.enabled": true,
+            "chat.provider": "discord",
+        },
+    },
+];
+/**
+ * Notification provider presets for quick setup.
+ */
+export const NOTIFICATION_PRESETS = [
+    {
+        id: "ntfy",
+        name: "ntfy",
+        description: "Simple HTTP-based pub-sub notifications",
+        category: "notifications",
+        fields: {
+            "notifications.provider": "ntfy",
+            "notifications.ntfy": {
+                topic: "",
+                server: "https://ntfy.sh",
+            },
+        },
+    },
+    {
+        id: "pushover",
+        name: "Pushover",
+        description: "Real-time notifications to iOS, Android, and Desktop",
+        category: "notifications",
+        fields: {
+            "notifications.provider": "pushover",
+            "notifications.pushover": {
+                user: "",
+                token: "",
+            },
+        },
+    },
+    {
+        id: "gotify",
+        name: "Gotify",
+        description: "Self-hosted push notification server",
+        category: "notifications",
+        fields: {
+            "notifications.provider": "gotify",
+            "notifications.gotify": {
+                server: "",
+                token: "",
+            },
+        },
+    },
+    {
+        id: "command",
+        name: "Custom Command",
+        description: "Execute a custom shell command for notifications",
+        category: "notifications",
+        fields: {
+            "notifications.provider": "command",
+            "notifications.command": "",
+        },
+    },
+];
+/**
+ * All available presets grouped by category.
+ */
+export const ALL_PRESETS = [...CHAT_PRESETS, ...NOTIFICATION_PRESETS];
+/**
+ * Get presets for a specific category.
+ */
+export function getPresetsForCategory(category) {
+    return ALL_PRESETS.filter((preset) => preset.category === category);
+}
+/**
+ * Get presets available for a specific config section.
+ * Maps section IDs to preset categories.
+ */
+export function getPresetsForSection(sectionId) {
+    switch (sectionId) {
+        case "chat":
+            return CHAT_PRESETS;
+        case "notifications":
+            return NOTIFICATION_PRESETS;
+        default:
+            return [];
+    }
+}
+/**
+ * Check if a section has available presets.
+ */
+export function sectionHasPresets(sectionId) {
+    return getPresetsForSection(sectionId).length > 0;
+}
+/**
+ * Apply a preset to a config object (immutably).
+ * Returns a new config with the preset fields applied.
+ */
+export function applyPreset(config, preset) {
+    const result = JSON.parse(JSON.stringify(config));
+    for (const [path, value] of Object.entries(preset.fields)) {
+        setValueAtPath(result, path, value);
+    }
+    return result;
+}
+/**
+ * Set a value at a dot-notation path in an object (mutates the object).
+ */
+function setValueAtPath(obj, path, value) {
+    const parts = path.split(".");
+    let current = obj;
+    for (let i = 0; i < parts.length - 1; i++) {
+        const part = parts[i];
+        if (current[part] === undefined || current[part] === null) {
+            current[part] = {};
+        }
+        current = current[part];
+    }
+    const lastPart = parts[parts.length - 1];
+    current[lastPart] = value;
+}
+/**
+ * Detect if a preset is currently active based on config values.
+ * Returns the preset ID if detected, or null if no preset matches.
+ */
+export function detectActivePreset(config, sectionId) {
+    const presets = getPresetsForSection(sectionId);
+    for (const preset of presets) {
+        // Check if the key distinguishing field matches
+        const mainField = Object.keys(preset.fields)[0];
+        const mainValue = getValueAtPath(config, mainField);
+        const presetValue = preset.fields[mainField];
+        if (mainValue === presetValue) {
+            return preset.id;
+        }
+    }
+    return null;
+}
+/**
+ * Get a value at a dot-notation path from an object.
+ */
+function getValueAtPath(obj, path) {
+    const parts = path.split(".");
+    let current = obj;
+    for (const part of parts) {
+        if (current === null || current === undefined) {
+            return undefined;
+        }
+        if (typeof current === "object") {
+            current = current[part];
+        }
+        else {
+            return undefined;
+        }
+    }
+    return current;
+}

package/dist/tui/utils/validation.d.ts

@@ -0,0 +1,49 @@
+import type { RalphConfig } from "../../utils/config.js";
+/**
+ * Validation error for a specific field.
+ */
+export interface ValidationError {
+    field: string;
+    message: string;
+    type: "required" | "format" | "pattern";
+}
+/**
+ * Result of validating a configuration.
+ */
+export interface ValidationResult {
+    valid: boolean;
+    errors: ValidationError[];
+}
+/**
+ * Validate that a port string matches the expected format.
+ * @param port - Port mapping string (e.g., "3000:3000")
+ * @returns true if valid, false otherwise
+ */
+export declare function validatePortFormat(port: string): boolean;
+/**
+ * Check if a required field has a valid non-empty value.
+ * @param value - The field value to check
+ * @returns true if valid, false otherwise
+ */
+export declare function isRequiredFieldValid(value: unknown): boolean;
+/**
+ * Validate the entire configuration.
+ * @param config - The configuration to validate
+ * @returns ValidationResult with valid flag and any errors found
+ */
+export declare function validateConfig(config: RalphConfig): ValidationResult;
+/**
+ * Get validation errors for a specific field path.
+ * Useful for inline error display in the editor.
+ * @param errors - List of all validation errors
+ * @param fieldPath - The field path to check (e.g., "language", "docker.ports")
+ * @returns Array of errors matching the field path
+ */
+export declare function getFieldErrors(errors: ValidationError[], fieldPath: string): ValidationError[];
+/**
+ * Check if a field has any validation errors.
+ * @param errors - List of all validation errors
+ * @param fieldPath - The field path to check
+ * @returns true if the field has errors, false otherwise
+ */
+export declare function hasFieldError(errors: ValidationError[], fieldPath: string): boolean;

package/dist/tui/utils/validation.js

@@ -0,0 +1,198 @@
+/**
+ * Required fields that cannot be empty.
+ */
+const REQUIRED_FIELDS = ["language", "checkCommand", "testCommand"];
+/**
+ * Port format pattern: host_port:container_port (e.g., "3000:3000", "8080:80")
+ */
+const PORT_PATTERN = /^\d+:\d+$/;
+/**
+ * Get a value at a dot-notation path from an object.
+ */
+function getValueAtPath(obj, path) {
+    const parts = path.split(".");
+    let current = obj;
+    for (const part of parts) {
+        if (current === null || current === undefined) {
+            return undefined;
+        }
+        if (typeof current === "object") {
+            current = current[part];
+        }
+        else {
+            return undefined;
+        }
+    }
+    return current;
+}
+/**
+ * Validate that a port string matches the expected format.
+ * @param port - Port mapping string (e.g., "3000:3000")
+ * @returns true if valid, false otherwise
+ */
+export function validatePortFormat(port) {
+    return PORT_PATTERN.test(port);
+}
+/**
+ * Check if a required field has a valid non-empty value.
+ * @param value - The field value to check
+ * @returns true if valid, false otherwise
+ */
+export function isRequiredFieldValid(value) {
+    if (value === null || value === undefined) {
+        return false;
+    }
+    if (typeof value === "string") {
+        return value.trim().length > 0;
+    }
+    return true;
+}
+/**
+ * Convert a field path to a human-readable label.
+ */
+function pathToLabel(path) {
+    const parts = path.split(".");
+    const lastPart = parts[parts.length - 1];
+    return lastPart
+        .replace(/([A-Z])/g, " $1")
+        .replace(/^./, (str) => str.toUpperCase())
+        .trim();
+}
+/**
+ * Validate required fields in the configuration.
+ */
+function validateRequiredFields(config) {
+    const errors = [];
+    for (const field of REQUIRED_FIELDS) {
+        const value = getValueAtPath(config, field);
+        if (!isRequiredFieldValid(value)) {
+            errors.push({
+                field,
+                message: `${pathToLabel(field)} is required and cannot be empty`,
+                type: "required",
+            });
+        }
+    }
+    return errors;
+}
+/**
+ * Validate port format for all docker ports.
+ */
+function validateDockerPorts(config) {
+    const errors = [];
+    const ports = config.docker?.ports;
+    if (!ports || !Array.isArray(ports)) {
+        return errors;
+    }
+    for (let i = 0; i < ports.length; i++) {
+        const port = ports[i];
+        if (typeof port === "string" && !validatePortFormat(port)) {
+            errors.push({
+                field: `docker.ports[${i}]`,
+                message: `Invalid port format: "${port}". Expected format: "host:container" (e.g., "3000:3000")`,
+                type: "pattern",
+            });
+        }
+    }
+    return errors;
+}
+/**
+ * Required keys for each notification provider.
+ */
+const NOTIFICATION_PROVIDER_REQUIRED_KEYS = {
+    ntfy: ["topic"],
+    pushover: ["user", "token"],
+    gotify: ["server", "token"],
+};
+/**
+ * Validate notification provider configuration.
+ * Checks that required keys are present for the selected provider.
+ */
+function validateNotificationProvider(config) {
+    const errors = [];
+    const notifications = config.notifications;
+    if (!notifications || !notifications.provider) {
+        return errors;
+    }
+    const provider = notifications.provider;
+    // Skip validation for command provider (uses command string instead of key-value)
+    if (provider === "command") {
+        return errors;
+    }
+    const requiredKeys = NOTIFICATION_PROVIDER_REQUIRED_KEYS[provider];
+    if (!requiredKeys) {
+        return errors;
+    }
+    const providerConfig = notifications[provider];
+    if (!providerConfig || typeof providerConfig !== "object") {
+        // Provider config is missing entirely
+        for (const key of requiredKeys) {
+            errors.push({
+                field: `notifications.${provider}.${key}`,
+                message: `${key} is required for ${provider} provider`,
+                type: "required",
+            });
+        }
+        return errors;
+    }
+    // Check each required key
+    const configObj = providerConfig;
+    for (const key of requiredKeys) {
+        const value = configObj[key];
+        if (!isRequiredFieldValid(value)) {
+            errors.push({
+                field: `notifications.${provider}.${key}`,
+                message: `${key} is required for ${provider} provider`,
+                type: "required",
+            });
+        }
+    }
+    return errors;
+}
+/**
+ * Validate the entire configuration.
+ * @param config - The configuration to validate
+ * @returns ValidationResult with valid flag and any errors found
+ */
+export function validateConfig(config) {
+    const errors = [];
+    // Check required fields
+    errors.push(...validateRequiredFields(config));
+    // Check docker port format
+    errors.push(...validateDockerPorts(config));
+    // Check notification provider required keys
+    errors.push(...validateNotificationProvider(config));
+    return {
+        valid: errors.length === 0,
+        errors,
+    };
+}
+/**
+ * Get validation errors for a specific field path.
+ * Useful for inline error display in the editor.
+ * @param errors - List of all validation errors
+ * @param fieldPath - The field path to check (e.g., "language", "docker.ports")
+ * @returns Array of errors matching the field path
+ */
+export function getFieldErrors(errors, fieldPath) {
+    return errors.filter((error) => {
+        // Exact match
+        if (error.field === fieldPath) {
+            return true;
+        }
+        // Array field match (e.g., "docker.ports" matches "docker.ports[0]")
+        if (error.field.startsWith(fieldPath + "[")) {
+            return true;
+        }
+        return false;
+    });
+}
+/**
+ * Check if a field has any validation errors.
+ * @param errors - List of all validation errors
+ * @param fieldPath - The field path to check
+ * @returns true if the field has errors, false otherwise
+ */
+export function hasFieldError(errors, fieldPath) {
+    return getFieldErrors(errors, fieldPath).length > 0;
+}

package/dist/utils/chat-client.d.ts

@@ -49,6 +49,24 @@ export type ChatCommandHandler = (command: ChatCommand) => Promise<void>;
  * Callback for handling raw messages (for custom processing).
  */
 export type ChatMessageHandler = (message: ChatMessage) => Promise<void>;
+/**
+ * Options for sending messages (provider-specific features).
+ */
+export interface SendMessageOptions {
+    /** Inline keyboard buttons (Telegram-specific) */
+    inlineKeyboard?: InlineButton[][];
+}
+/**
+ * Inline button for chat messages.
+ */
+export interface InlineButton {
+    /** Button text displayed to user */
+    text: string;
+    /** Callback data sent when button is pressed (used as command) */
+    callbackData?: string;
+    /** URL to open when button is pressed */
+    url?: string;
+}
 /**
  * Abstract interface for chat clients.
  * Implementations should handle provider-specific API calls.
@@ -66,8 +84,9 @@ export interface ChatClient {
      * Send a text message to a specific chat.
      * @param chatId The chat ID to send to
      * @param text The message text
+     * @param options Optional message options (e.g., inline keyboard)
      */
-    sendMessage(chatId: string, text: string): Promise<void>;
+    sendMessage(chatId: string, text: string, options?: SendMessageOptions): Promise<void>;
     /**
      * Disconnect from the chat service.
      */
@@ -108,6 +127,17 @@ export declare function generateProjectId(): string;
  * - "/add Fix the login bug" -> { command: "add", args: ["Fix", "the", "login", "bug"] }
  */
 export declare function parseCommand(text: string, message: ChatMessage): ChatCommand | null;
+/**
+ * Strip ANSI escape codes from a string.
+ * This is useful for cleaning output before sending to chat services
+ * that don't support terminal formatting.
+ */
+export declare function stripAnsiCodes(text: string): string;
+/**
+ * Format status output for chat by stripping ANSI codes and removing
+ * progress bars that don't render well in chat.
+ */
+export declare function formatStatusForChat(output: string): string;
 /**
  * Format a status message for a project.
  */

package/dist/utils/chat-client.js

@@ -28,7 +28,7 @@ export function parseCommand(text, message) {
     if (!trimmed)
         return null;
     // Valid commands
-    const validCommands = ["run", "status", "add", "exec", "stop", "help", "start", "action"];
+    const validCommands = ["run", "status", "add", "exec", "stop", "help", "start", "action", "claude"];
     // Check for slash command format: /command [args...]
     if (trimmed.startsWith("/")) {
         const parts = trimmed.slice(1).split(/\s+/);
@@ -57,6 +57,32 @@ export function parseCommand(text, message) {
     }
     return null;
 }
+/**
+ * Strip ANSI escape codes from a string.
+ * This is useful for cleaning output before sending to chat services
+ * that don't support terminal formatting.
+ */
+export function stripAnsiCodes(text) {
+    // Match ANSI escape sequences: ESC[...m (SGR), ESC[...K (EL), etc.
+    return text.replace(/\x1B\[[0-9;]*[mKJHfsu]/g, "");
+}
+/**
+ * Format status output for chat by stripping ANSI codes and removing
+ * progress bars that don't render well in chat.
+ */
+export function formatStatusForChat(output) {
+    // Strip ANSI escape codes
+    let cleaned = stripAnsiCodes(output);
+    // Remove progress bar lines (lines with block characters ██░)
+    // These don't render well in chat clients
+    cleaned = cleaned
+        .split("\n")
+        .filter((line) => !line.includes("█") && !line.includes("░"))
+        .join("\n");
+    // Clean up extra blank lines that may result from removing progress bar
+    cleaned = cleaned.replace(/\n{3,}/g, "\n\n");
+    return cleaned.trim();
+}
 /**
  * Format a status message for a project.
  */

package/dist/utils/config.d.ts

@@ -31,13 +31,18 @@ export interface DaemonActionConfig {
     command: string;
     description?: string;
 }
+export interface NotificationProviderConfig {
+    [key: string]: string | undefined;
+}
 export interface NtfyNotificationConfig {
     topic: string;
     server?: string;
 }
 export interface NotificationsConfig {
-    provider: "ntfy" | "command";
-    ntfy?: NtfyNotificationConfig;
+    provider: "ntfy" | "pushover" | "gotify" | "command";
+    ntfy?: NotificationProviderConfig;
+    pushover?: NotificationProviderConfig;
+    gotify?: NotificationProviderConfig;
     command?: string;
 }
 /**