shellfie-cli 2.0.1 → 2.0.2

package/dist/dvd-executor.js

@@ -0,0 +1,669 @@
+"use strict";
+/**
+ * DVD Command Executor
+ * Executes real commands with typing effect and cursor
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DVDExecutor = void 0;
+const node_child_process_1 = require("node:child_process");
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const terminal_renderer_1 = require("./terminal-renderer");
+const shellfie_1 = require("shellfie");
+class DVDExecutor {
+    context;
+    options;
+    constructor(options = {}) {
+        this.options = options;
+        this.context = {
+            lines: [''],
+            currentLine: '',
+            cursorX: 0,
+            cursorY: 0,
+            frames: [],
+            clipboard: '',
+            startTime: Date.now(),
+            width: options.width || 800,
+            height: options.height || 600,
+            fontSize: options.fontSize || 14,
+            typingSpeed: 50, // Default 50ms per character
+            title: options.title,
+            template: options.template || 'macos',
+            promptPrefix: '\x1b[95m❯\x1b[0m ', // Default: pink > character
+            cursorBlink: true, // Default: cursor blinks
+            screenshotCounter: 0,
+        };
+    }
+    /**
+     * Capture current terminal state as a frame
+     */
+    captureFrame(showCursor = true, activeCursor = false) {
+        const buffer = [...this.context.lines];
+        buffer[this.context.cursorY] = this.context.currentLine;
+        const state = (0, terminal_renderer_1.createTerminalState)(buffer.join('\n'), this.context.cursorX, this.context.cursorY, this.context.width, this.context.height, this.context.fontSize, showCursor, activeCursor, this.context.selectionStart, this.context.selectionEnd);
+        const svg = (0, terminal_renderer_1.renderTerminalSVG)(state, {
+            title: this.context.title,
+            template: this.context.template,
+            theme: this.context.theme,
+            watermark: this.context.watermark,
+        });
+        const frame = {
+            timestamp: Date.now() - this.context.startTime,
+            svg,
+            state,
+        };
+        this.context.frames.push(frame);
+        this.options.onFrame?.(frame);
+    }
+    /**
+     * Execute Type command - simulate typing character by character
+     */
+    async executeType(text, speed, prefix) {
+        const delay = speed || this.context.typingSpeed;
+        const promptPrefix = prefix ?? this.context.promptPrefix;
+        // If there's a selection, delete it first
+        if (this.hasSelection()) {
+            this.deleteSelection();
+            this.captureFrame(true, true);
+            await new Promise((resolve) => setTimeout(resolve, delay));
+        }
+        // Check if we need to add a prefix
+        // Add prefix if: line is empty OR line only contains the prefix already
+        const shouldAddPrefix = promptPrefix &&
+            (this.context.currentLine === '' || this.context.currentLine === promptPrefix);
+        if (shouldAddPrefix && this.context.currentLine === '') {
+            // Only add prefix if line is completely empty
+            this.context.currentLine = promptPrefix;
+            this.context.cursorX = this.stripAnsi(promptPrefix).length;
+            this.captureFrame(true, true); // active cursor during prefix
+            await new Promise((resolve) => setTimeout(resolve, delay));
+        }
+        for (const char of text) {
+            this.context.currentLine += char;
+            this.context.cursorX++;
+            // Capture frame showing the new character with active cursor (no blink during typing)
+            await new Promise((resolve) => setTimeout(resolve, delay));
+            this.captureFrame(true, true);
+        }
+    }
+    /**
+     * Strip ANSI escape codes to get actual string length
+     */
+    stripAnsi(str) {
+        // eslint-disable-next-line no-control-regex
+        return str.replace(/\x1b\[[0-9;]*m/g, '');
+    }
+    /**
+     * Execute Enter - run the command and capture streaming output
+     */
+    async executeEnter() {
+        const fullLine = this.context.currentLine;
+        // Strip the prompt prefix from the command before executing
+        // Check if the line starts with the prefix and remove it
+        let command = fullLine;
+        if (this.context.promptPrefix && fullLine.startsWith(this.context.promptPrefix)) {
+            command = fullLine.slice(this.context.promptPrefix.length);
+        }
+        command = command.trim();
+        // Finalize current line (the command that was typed - keep the visual prefix)
+        this.context.lines[this.context.cursorY] = this.context.currentLine;
+        // Move to next line
+        this.context.cursorY++;
+        this.context.cursorX = 0;
+        this.context.currentLine = '';
+        if (!this.context.lines[this.context.cursorY]) {
+            this.context.lines[this.context.cursorY] = '';
+        }
+        // Capture frame showing command was submitted (cursor on new line)
+        await new Promise((resolve) => setTimeout(resolve, 100));
+        this.captureFrame(true);
+        // Execute the command if it's not empty
+        if (command) {
+            await this.executeCommandStreaming(command);
+        }
+    }
+    /**
+     * Execute command with streaming output support
+     */
+    async executeCommandStreaming(command) {
+        return new Promise((resolve) => {
+            const child = (0, node_child_process_1.spawn)(command, [], {
+                shell: true,
+                env: { ...process.env, FORCE_COLOR: '1', CLICOLOR_FORCE: '1' },
+            });
+            let outputBuffer = '';
+            let lastFrameTime = Date.now();
+            const FRAME_INTERVAL = 100; // Capture frame every 100ms when output is streaming
+            const processOutput = (data) => {
+                outputBuffer += data;
+                // Process complete lines
+                const lines = outputBuffer.split('\n');
+                outputBuffer = lines.pop() || ''; // Keep incomplete line in buffer
+                for (const line of lines) {
+                    this.context.lines[this.context.cursorY] = line;
+                    this.context.cursorY++;
+                    this.context.lines[this.context.cursorY] = '';
+                    // Capture frame if enough time has passed (for animations)
+                    const now = Date.now();
+                    if (now - lastFrameTime >= FRAME_INTERVAL) {
+                        this.captureFrame(true);
+                        lastFrameTime = now;
+                    }
+                }
+            };
+            child.stdout?.on('data', (data) => {
+                processOutput(data.toString());
+            });
+            child.stderr?.on('data', (data) => {
+                processOutput(data.toString());
+            });
+            child.on('close', () => {
+                // Process any remaining buffered output
+                if (outputBuffer) {
+                    this.context.lines[this.context.cursorY] = outputBuffer;
+                    this.context.cursorY++;
+                    this.context.lines[this.context.cursorY] = '';
+                }
+                // Add prompt prefix to the new line after command completes
+                this.context.currentLine = this.context.promptPrefix;
+                this.context.cursorX = this.stripAnsi(this.context.promptPrefix).length;
+                // Capture final frame with cursor on new line with prefix
+                setTimeout(() => {
+                    this.captureFrame(true);
+                    resolve();
+                }, 100);
+            });
+            child.on('error', (err) => {
+                this.context.lines[this.context.cursorY] = `Command failed: ${err.message}`;
+                this.context.cursorY++;
+                this.context.lines[this.context.cursorY] = '';
+                // Add prompt prefix to the new line after error
+                this.context.currentLine = this.context.promptPrefix;
+                this.context.cursorX = this.stripAnsi(this.context.promptPrefix).length;
+                this.captureFrame(true);
+                resolve();
+            });
+        });
+    }
+    /**
+     * Execute arrow keys
+     */
+    async executeArrow(direction) {
+        switch (direction) {
+            case 'Left':
+                if (this.context.cursorX > 0)
+                    this.context.cursorX--;
+                break;
+            case 'Right':
+                if (this.context.cursorX < this.context.currentLine.length)
+                    this.context.cursorX++;
+                break;
+            case 'Up':
+                if (this.context.cursorY > 0) {
+                    this.context.cursorY--;
+                    this.context.currentLine = this.context.lines[this.context.cursorY];
+                    this.context.cursorX = Math.min(this.context.cursorX, this.context.currentLine.length);
+                }
+                break;
+            case 'Down':
+                if (this.context.cursorY < this.context.lines.length - 1) {
+                    this.context.cursorY++;
+                    this.context.currentLine = this.context.lines[this.context.cursorY];
+                    this.context.cursorX = Math.min(this.context.cursorX, this.context.currentLine.length);
+                }
+                break;
+        }
+        await new Promise((resolve) => setTimeout(resolve, 50));
+        this.captureFrame(true, true); // active cursor during arrow key movement
+    }
+    /**
+     * Execute Screenshot - save current terminal state as static SVG using shellfie
+     */
+    async executeScreenshot(path) {
+        // Determine the screenshot path
+        let screenshotPath;
+        if (path) {
+            screenshotPath = path;
+        }
+        else {
+            // Auto-generate name based on Output path
+            const baseName = this.context.outputPath
+                ? this.context.outputPath.replace(/\.svg$/, '')
+                : 'screenshot';
+            screenshotPath = `${baseName}_screenshot_${this.context.screenshotCounter}.svg`;
+            this.context.screenshotCounter++;
+        }
+        // Get current terminal content
+        const buffer = [...this.context.lines];
+        buffer[this.context.cursorY] = this.context.currentLine;
+        const content = buffer.join('\n');
+        // Use shellfie to generate static SVG with exact dimensions to match animated frames
+        // Create a custom template with shadow disabled to match terminal-renderer
+        let templateOption = this.context.template;
+        if (typeof this.context.template === 'string') {
+            // For built-in templates, create a custom version with shadow disabled
+            const { templates } = await import('shellfie');
+            const baseTemplate = templates[this.context.template];
+            if (baseTemplate) {
+                templateOption = {
+                    ...baseTemplate,
+                    shell: {
+                        ...baseTemplate.shell,
+                        shadow: false, // Disable shadow to match terminal-renderer
+                    },
+                };
+            }
+        }
+        const svg = (0, shellfie_1.shellfie)(content, {
+            width: this.context.width,
+            height: this.context.height,
+            fontSize: this.context.fontSize,
+            title: this.context.title,
+            template: templateOption,
+            theme: this.context.theme,
+            watermark: this.context.watermark,
+            // Enable title bar border to match terminal-renderer
+            header: {
+                border: true,
+                borderColor: '#d4d4d41a',
+                borderWidth: 1,
+            },
+        });
+        // Write to file
+        (0, node_fs_1.writeFileSync)((0, node_path_1.resolve)(screenshotPath), svg, 'utf-8');
+    }
+    /**
+     * Execute Backspace - delete characters with animation
+     */
+    async executeBackspace(count = 1) {
+        const delay = this.context.typingSpeed;
+        // If there's a selection, delete it instead of normal backspace
+        if (this.hasSelection()) {
+            this.deleteSelection();
+            await new Promise((resolve) => setTimeout(resolve, delay));
+            this.captureFrame(true, true);
+            return;
+        }
+        for (let i = 0; i < count; i++) {
+            if (this.context.currentLine.length > 0) {
+                // Always delete from the end of the line (like a real terminal)
+                this.context.currentLine = this.context.currentLine.slice(0, -1);
+                this.context.cursorX--;
+                await new Promise((resolve) => setTimeout(resolve, delay));
+                this.captureFrame(true, true); // active cursor during backspace
+            }
+        }
+    }
+    /**
+     * Execute keyboard shortcut with modifiers
+     */
+    async executeShortcut(ctrl, alt, shift, cmd, key) {
+        // Normalize Cmd to Ctrl for cross-platform compatibility
+        const metaKey = cmd || ctrl;
+        // Handle different shortcut combinations
+        if (shift && !alt && !metaKey) {
+            // Shift + Arrow keys = Selection
+            if (key === 'Left' || key === 'Right') {
+                await this.executeSelectionMove(key === 'Right', shift);
+            }
+        }
+        else if (alt && shift && !metaKey) {
+            // Alt + Shift + Arrow = Word selection
+            if (key === 'Left' || key === 'Right') {
+                await this.executeWordSelection(key === 'Right');
+            }
+        }
+        else if (alt && !shift && !metaKey) {
+            // Alt + Arrow = Word movement
+            if (key === 'Left' || key === 'Right') {
+                await this.executeWordMove(key === 'Right');
+            }
+        }
+        else if (metaKey && !alt && !shift) {
+            // Cmd/Ctrl + Arrow = Line navigation
+            if (key === 'Left' || key === 'Right') {
+                await this.executeLineNavigation(key === 'Right');
+            }
+            else if (key === 'Backspace') {
+                await this.executeWordDelete();
+            }
+        }
+    }
+    /**
+     * Execute selection movement (Shift + Left/Right)
+     */
+    async executeSelectionMove(right, shift) {
+        const strippedLine = this.stripAnsi(this.context.currentLine);
+        // Initialize selection anchor if not already set
+        if (!shift || (this.context.selectionStart === undefined && this.context.selectionEnd === undefined)) {
+            this.context.selectionStart = this.context.cursorX;
+            this.context.selectionEnd = this.context.cursorX;
+        }
+        // Move cursor
+        if (right) {
+            if (this.context.cursorX < strippedLine.length) {
+                this.context.cursorX++;
+            }
+        }
+        else {
+            if (this.context.cursorX > 0) {
+                this.context.cursorX--;
+            }
+        }
+        // Update selection end
+        if (shift) {
+            this.context.selectionEnd = this.context.cursorX;
+        }
+        else {
+            this.clearSelection();
+        }
+        await new Promise((resolve) => setTimeout(resolve, 50));
+        this.captureFrame(true, true);
+    }
+    /**
+     * Execute word movement (Alt + Left/Right)
+     */
+    async executeWordMove(right) {
+        const strippedLine = this.stripAnsi(this.context.currentLine);
+        this.clearSelection(); // Clear any selection
+        const direction = right ? 'right' : 'left';
+        const newPosition = this.findWordBoundary(direction, this.context.cursorX, this.context.currentLine);
+        this.context.cursorX = newPosition;
+        await new Promise((resolve) => setTimeout(resolve, 50));
+        this.captureFrame(true, true);
+    }
+    /**
+     * Execute word selection (Alt + Shift + Left/Right)
+     */
+    async executeWordSelection(right) {
+        // Initialize selection if not set
+        if (this.context.selectionStart === undefined) {
+            this.context.selectionStart = this.context.cursorX;
+            this.context.selectionEnd = this.context.cursorX;
+        }
+        const direction = right ? 'right' : 'left';
+        const newPosition = this.findWordBoundary(direction, this.context.cursorX, this.context.currentLine);
+        this.context.cursorX = newPosition;
+        this.context.selectionEnd = newPosition;
+        await new Promise((resolve) => setTimeout(resolve, 50));
+        this.captureFrame(true, true);
+    }
+    /**
+     * Execute line navigation (Cmd/Ctrl + Left/Right)
+     */
+    async executeLineNavigation(toEnd) {
+        const strippedLine = this.stripAnsi(this.context.currentLine);
+        this.clearSelection(); // Clear any selection
+        if (toEnd) {
+            // Move to end of line
+            this.context.cursorX = strippedLine.length;
+        }
+        else {
+            // Move to beginning of line (after prompt if it exists)
+            const promptLength = this.context.promptPrefix ? this.stripAnsi(this.context.promptPrefix).length : 0;
+            this.context.cursorX = promptLength;
+        }
+        await new Promise((resolve) => setTimeout(resolve, 50));
+        this.captureFrame(true, true);
+    }
+    /**
+     * Execute word deletion (Cmd/Ctrl + Backspace)
+     */
+    async executeWordDelete() {
+        const delay = this.context.typingSpeed;
+        const strippedLine = this.stripAnsi(this.context.currentLine);
+        // Find word boundary to the left
+        const wordStart = this.findWordBoundary('left', this.context.cursorX, this.context.currentLine);
+        // Calculate how many characters to delete
+        const deleteCount = this.context.cursorX - wordStart;
+        if (deleteCount <= 0)
+            return;
+        // Animate deletion character by character
+        for (let i = 0; i < deleteCount; i++) {
+            if (this.context.currentLine.length > 0) {
+                this.context.currentLine = this.context.currentLine.slice(0, -1);
+                this.context.cursorX--;
+                await new Promise((resolve) => setTimeout(resolve, delay / 2)); // Faster than regular backspace
+                this.captureFrame(true, true);
+            }
+        }
+    }
+    /**
+     * Check if there's an active selection
+     */
+    hasSelection() {
+        return (this.context.selectionStart !== undefined &&
+            this.context.selectionEnd !== undefined &&
+            this.context.selectionStart !== this.context.selectionEnd);
+    }
+    /**
+     * Get selected text
+     */
+    getSelectedText() {
+        if (!this.hasSelection())
+            return '';
+        const start = Math.min(this.context.selectionStart, this.context.selectionEnd);
+        const end = Math.max(this.context.selectionStart, this.context.selectionEnd);
+        const strippedLine = this.stripAnsi(this.context.currentLine);
+        return strippedLine.substring(start, end);
+    }
+    /**
+     * Clear selection
+     */
+    clearSelection() {
+        this.context.selectionStart = undefined;
+        this.context.selectionEnd = undefined;
+    }
+    /**
+     * Delete selected text and return true if selection was deleted
+     */
+    deleteSelection() {
+        if (!this.hasSelection())
+            return false;
+        const start = Math.min(this.context.selectionStart, this.context.selectionEnd);
+        const end = Math.max(this.context.selectionStart, this.context.selectionEnd);
+        // Map visual positions to actual positions in currentLine (with ANSI codes)
+        const strippedLine = this.stripAnsi(this.context.currentLine);
+        const before = strippedLine.substring(0, start);
+        const after = strippedLine.substring(end);
+        // Rebuild line - this is simplified, should preserve ANSI codes properly
+        this.context.currentLine = before + after;
+        this.context.cursorX = start;
+        this.clearSelection();
+        return true;
+    }
+    /**
+     * Find word boundary in the given direction
+     * Returns the position of the word boundary
+     */
+    findWordBoundary(direction, position, text) {
+        const stripped = this.stripAnsi(text);
+        if (direction === 'left') {
+            // Move left to find word boundary
+            if (position === 0)
+                return 0;
+            let pos = position - 1;
+            // Skip whitespace
+            while (pos > 0 && /\s/.test(stripped[pos])) {
+                pos--;
+            }
+            // Skip word characters
+            if (/\w/.test(stripped[pos])) {
+                while (pos > 0 && /\w/.test(stripped[pos - 1])) {
+                    pos--;
+                }
+            }
+            else if (/\S/.test(stripped[pos])) {
+                // Skip punctuation (non-whitespace, non-word)
+                while (pos > 0 && /[^\w\s]/.test(stripped[pos - 1])) {
+                    pos--;
+                }
+            }
+            return pos;
+        }
+        else {
+            // Move right to find word boundary
+            if (position >= stripped.length)
+                return stripped.length;
+            let pos = position;
+            // Skip whitespace
+            while (pos < stripped.length && /\s/.test(stripped[pos])) {
+                pos++;
+            }
+            // Skip word characters
+            if (pos < stripped.length && /\w/.test(stripped[pos])) {
+                while (pos < stripped.length && /\w/.test(stripped[pos])) {
+                    pos++;
+                }
+            }
+            else if (pos < stripped.length && /\S/.test(stripped[pos])) {
+                // Skip punctuation
+                while (pos < stripped.length && /[^\w\s]/.test(stripped[pos])) {
+                    pos++;
+                }
+            }
+            return pos;
+        }
+    }
+    /**
+     * Execute a single command
+     */
+    async executeCommand(command) {
+        switch (command.type) {
+            case 'Type':
+                await this.executeType(command.text, command.speed, command.prefix);
+                break;
+            case 'Key':
+                if (['Left', 'Right', 'Up', 'Down'].includes(command.key)) {
+                    const count = command.count || 1;
+                    for (let i = 0; i < count; i++) {
+                        await this.executeArrow(command.key);
+                    }
+                }
+                else if (command.key === 'Enter') {
+                    await this.executeEnter();
+                }
+                else if (command.key === 'Backspace') {
+                    await this.executeBackspace(command.count || 1);
+                }
+                else if (command.key === 'Space') {
+                    const count = command.count || 1;
+                    await this.executeType(' '.repeat(count));
+                }
+                else if (command.key === 'Tab') {
+                    const count = command.count || 1;
+                    await this.executeType('    '.repeat(count)); // 4 spaces per tab
+                }
+                break;
+            case 'Sleep':
+                await new Promise((resolve) => setTimeout(resolve, command.duration));
+                this.captureFrame(true);
+                break;
+            case 'Screenshot':
+                await this.executeScreenshot(command.path);
+                break;
+            case 'Copy':
+                this.context.clipboard = command.text;
+                break;
+            case 'Paste':
+                if (this.context.clipboard) {
+                    await this.executeType(this.context.clipboard);
+                }
+                break;
+            case 'Shortcut':
+                await this.executeShortcut(command.ctrl, command.alt, command.shift, command.cmd, command.key);
+                break;
+            case 'Hide':
+            case 'Show':
+            case 'Output':
+            case 'Require':
+            case 'Set':
+            case 'Source':
+            case 'Env':
+            case 'Comment':
+            case 'Wait':
+                // Not implemented in simulation mode
+                break;
+        }
+    }
+    /**
+     * Execute complete DVD script
+     */
+    async execute(script) {
+        // Apply settings
+        for (const [key, value] of script.settings.entries()) {
+            if (key === 'Width')
+                this.context.width = parseInt(value, 10);
+            if (key === 'Height')
+                this.context.height = parseInt(value, 10);
+            if (key === 'FontSize')
+                this.context.fontSize = parseInt(value, 10);
+            if (key === 'TypingSpeed')
+                this.context.typingSpeed = parseInt(value, 10);
+            if (key === 'Title')
+                this.context.title = value;
+            if (key === 'Template')
+                this.context.template = value;
+            if (key === 'Theme') {
+                // Look up theme from shellfie themes
+                const themeName = value;
+                if (shellfie_1.themes[themeName]) {
+                    this.context.theme = shellfie_1.themes[themeName];
+                }
+            }
+            if (key === 'PromptPrefix') {
+                // Parse the string to handle escape sequences
+                this.context.promptPrefix = value
+                    .replace(/\\e/g, '\x1b')
+                    .replace(/\\x1b/g, '\x1b')
+                    .replace(/\\n/g, '\n')
+                    .replace(/\\t/g, '\t');
+            }
+            if (key === 'Watermark') {
+                // Parse the string to handle escape sequences (same as PromptPrefix)
+                this.context.watermark = value
+                    .replace(/\\e/g, '\x1b')
+                    .replace(/\\x1b/g, '\x1b')
+                    .replace(/\\n/g, '\n')
+                    .replace(/\\t/g, '\t');
+            }
+            if (key === 'CursorBlink') {
+                this.context.cursorBlink = value.toLowerCase() !== 'false';
+            }
+        }
+        // Store output path for auto-naming screenshots
+        this.context.outputPath = script.output;
+        // Capture initial frame
+        this.captureFrame(true);
+        // Execute commands
+        const actionCommands = script.commands.filter((cmd) => !['Output', 'Require', 'Set', 'Env'].includes(cmd.type));
+        for (let i = 0; i < actionCommands.length; i++) {
+            const cmd = actionCommands[i];
+            // Create progress message with command type BEFORE executing
+            let cmdDescription = cmd.type;
+            if (cmd.type === 'Key') {
+                cmdDescription = cmd.key;
+            }
+            this.options.onProgress?.(i + 1, actionCommands.length, cmdDescription);
+            // Now execute the command
+            await this.executeCommand(cmd);
+        }
+        // Capture final frame without cursor
+        this.captureFrame(false);
+        return this.context.frames;
+    }
+    /**
+     * Get all captured frames
+     */
+    getFrames() {
+        return this.context.frames;
+    }
+    /**
+     * Cleanup (no-op for simulation)
+     */
+    async cleanup() {
+        // Nothing to clean up in simulation mode
+    }
+}
+exports.DVDExecutor = DVDExecutor;
+//# sourceMappingURL=dvd-executor.js.map