browser-terminal-cli 1.0.0

package/dist/index.esm.js

@@ -0,0 +1,1038 @@
+const themes = {
+    default: {
+        background: '#1e1e1e',
+        foreground: '#d4d4d4',
+        cursor: '#ffffff',
+        cursorAccent: '#000000',
+        selection: 'rgba(255, 255, 255, 0.3)',
+        black: '#000000',
+        red: '#cd3131',
+        green: '#0dbc79',
+        yellow: '#e5e510',
+        blue: '#2472c8',
+        magenta: '#bc3fbc',
+        cyan: '#11a8cd',
+        white: '#e5e5e5',
+        brightBlack: '#666666',
+        brightRed: '#f14c4c',
+        brightGreen: '#23d18b',
+        brightYellow: '#f5f543',
+        brightBlue: '#3b8eea',
+        brightMagenta: '#d670d6',
+        brightCyan: '#29b8db',
+        brightWhite: '#ffffff',
+    },
+    dark: {
+        background: '#0d1117',
+        foreground: '#c9d1d9',
+        cursor: '#58a6ff',
+        selection: 'rgba(56, 139, 253, 0.4)',
+        black: '#484f58',
+        red: '#ff7b72',
+        green: '#3fb950',
+        yellow: '#d29922',
+        blue: '#58a6ff',
+        magenta: '#bc8cff',
+        cyan: '#39c5cf',
+        white: '#b1bac4',
+    },
+    light: {
+        background: '#ffffff',
+        foreground: '#333333',
+        cursor: '#000000',
+        selection: 'rgba(0, 0, 0, 0.2)',
+        black: '#000000',
+        red: '#c91b00',
+        green: '#00c200',
+        yellow: '#c7c400',
+        blue: '#0225c7',
+        magenta: '#c930c7',
+        cyan: '#00c5c7',
+        white: '#c7c7c7',
+    },
+    matrix: {
+        background: '#0d0208',
+        foreground: '#00ff41',
+        cursor: '#00ff41',
+        selection: 'rgba(0, 255, 65, 0.3)',
+        black: '#0d0208',
+        red: '#00ff41',
+        green: '#00ff41',
+        yellow: '#00ff41',
+        blue: '#003b00',
+        magenta: '#00ff41',
+        cyan: '#00ff41',
+        white: '#00ff41',
+    },
+    ubuntu: {
+        background: '#300a24',
+        foreground: '#eeeeec',
+        cursor: '#bbbbbb',
+        selection: 'rgba(255, 255, 255, 0.3)',
+        black: '#2e3436',
+        red: '#cc0000',
+        green: '#4e9a06',
+        yellow: '#c4a000',
+        blue: '#3465a4',
+        magenta: '#75507b',
+        cyan: '#06989a',
+        white: '#d3d7cf',
+    },
+    monokai: {
+        background: '#272822',
+        foreground: '#f8f8f2',
+        cursor: '#f8f8f2',
+        selection: 'rgba(73, 72, 62, 0.8)',
+        black: '#272822',
+        red: '#f92672',
+        green: '#a6e22e',
+        yellow: '#f4bf75',
+        blue: '#66d9ef',
+        magenta: '#ae81ff',
+        cyan: '#a1efe4',
+        white: '#f8f8f2',
+    },
+    dracula: {
+        background: '#282a36',
+        foreground: '#f8f8f2',
+        cursor: '#f8f8f2',
+        selection: 'rgba(68, 71, 90, 0.8)',
+        black: '#21222c',
+        red: '#ff5555',
+        green: '#50fa7b',
+        yellow: '#f1fa8c',
+        blue: '#bd93f9',
+        magenta: '#ff79c6',
+        cyan: '#8be9fd',
+        white: '#f8f8f2',
+    },
+    'solarized-dark': {
+        background: '#002b36',
+        foreground: '#839496',
+        cursor: '#839496',
+        selection: 'rgba(7, 54, 66, 0.8)',
+        black: '#073642',
+        red: '#dc322f',
+        green: '#859900',
+        yellow: '#b58900',
+        blue: '#268bd2',
+        magenta: '#d33682',
+        cyan: '#2aa198',
+        white: '#eee8d5',
+    },
+    'solarized-light': {
+        background: '#fdf6e3',
+        foreground: '#657b83',
+        cursor: '#657b83',
+        selection: 'rgba(238, 232, 213, 0.8)',
+        black: '#073642',
+        red: '#dc322f',
+        green: '#859900',
+        yellow: '#b58900',
+        blue: '#268bd2',
+        magenta: '#d33682',
+        cyan: '#2aa198',
+        white: '#fdf6e3',
+    },
+};
+function getTheme(theme) {
+    if (typeof theme === 'string') {
+        return themes[theme] || themes.default;
+    }
+    return { ...themes.default, ...theme };
+}
+
+function generateStyles(containerId, theme, options) {
+    const fontSize = options.fontSize || 14;
+    const fontFamily = options.fontFamily || "'Cascadia Code', 'Fira Code', 'Consolas', 'Monaco', monospace";
+    const cursorStyle = options.cursorStyle || 'block';
+    const cursorBlink = options.cursorBlink !== false;
+    let cursorWidth = '8px';
+    let cursorHeight = '100%';
+    if (cursorStyle === 'underline') {
+        cursorWidth = '8px';
+        cursorHeight = '2px';
+    }
+    else if (cursorStyle === 'bar') {
+        cursorWidth = '2px';
+        cursorHeight = '100%';
+    }
+    return `
+    #${containerId} {
+      background-color: ${theme.background};
+      color: ${theme.foreground};
+      font-family: ${fontFamily};
+      font-size: ${fontSize}px;
+      line-height: 1.5;
+      padding: 16px;
+      overflow-y: auto;
+      height: 100%;
+      box-sizing: border-box;
+      position: relative;
+    }
+
+    #${containerId} * {
+      box-sizing: border-box;
+    }
+
+    #${containerId}::-webkit-scrollbar {
+      width: 10px;
+    }
+
+    #${containerId}::-webkit-scrollbar-track {
+      background: ${theme.background};
+    }
+
+    #${containerId}::-webkit-scrollbar-thumb {
+      background: ${theme.foreground}33;
+      border-radius: 5px;
+    }
+
+    #${containerId}::-webkit-scrollbar-thumb:hover {
+      background: ${theme.foreground}55;
+    }
+
+    #${containerId} .terminal-output {
+      white-space: pre-wrap;
+      word-wrap: break-word;
+    }
+
+    #${containerId} .terminal-line {
+      display: flex;
+      flex-wrap: wrap;
+      margin: 0;
+      padding: 0;
+    }
+
+    #${containerId} .terminal-prompt {
+      color: ${theme.green || '#00ff00'};
+      margin-right: 8px;
+      user-select: none;
+      flex-shrink: 0;
+    }
+
+    #${containerId} .terminal-input-wrapper {
+      display: flex;
+      flex: 1;
+      min-width: 0;
+      position: relative;
+    }
+
+    #${containerId} .terminal-input {
+      background: transparent;
+      border: none;
+      outline: none;
+      color: ${theme.foreground};
+      font-family: inherit;
+      font-size: inherit;
+      flex: 1;
+      min-width: 0;
+      caret-color: transparent;
+      padding: 0;
+      margin: 0;
+    }
+
+    #${containerId} .terminal-input::selection {
+      background: ${theme.selection || 'rgba(255, 255, 255, 0.3)'};
+    }
+
+    #${containerId} .terminal-cursor {
+      display: inline-block;
+      width: ${cursorWidth};
+      height: ${cursorHeight};
+      background-color: ${theme.cursor};
+      position: absolute;
+      pointer-events: none;
+      ${cursorStyle === 'underline' ? 'bottom: 2px;' : ''}
+      ${cursorBlink ? `animation: terminal-cursor-blink-${containerId} 1s step-end infinite;` : ''}
+    }
+
+    @keyframes terminal-cursor-blink-${containerId} {
+      0%, 100% { opacity: 1; }
+      50% { opacity: 0; }
+    }
+
+    #${containerId} .terminal-hidden-input {
+      position: absolute;
+      left: -9999px;
+      opacity: 0;
+    }
+
+    #${containerId} .terminal-history-line {
+      margin: 0;
+      padding: 0;
+    }
+
+    #${containerId} .terminal-error {
+      color: ${theme.red || '#ff0000'};
+    }
+
+    #${containerId} .terminal-success {
+      color: ${theme.green || '#00ff00'};
+    }
+
+    #${containerId} .terminal-warning {
+      color: ${theme.yellow || '#ffff00'};
+    }
+
+    #${containerId} .terminal-info {
+      color: ${theme.blue || '#0000ff'};
+    }
+
+    #${containerId} .text-bold {
+      font-weight: bold;
+    }
+
+    #${containerId} .text-italic {
+      font-style: italic;
+    }
+
+    #${containerId} .text-underline {
+      text-decoration: underline;
+    }
+
+    #${containerId}.terminal-disabled {
+      opacity: 0.7;
+      pointer-events: none;
+    }
+  `;
+}
+
+class HistoryManager {
+    constructor(maxSize = 100) {
+        this.history = [];
+        this.historyIndex = -1;
+        this.tempInput = '';
+        this.maxSize = maxSize;
+    }
+    add(command) {
+        if (!command.trim())
+            return;
+        // Avoid duplicates at the end
+        if (this.history[this.history.length - 1] === command) {
+            this.historyIndex = -1;
+            return;
+        }
+        this.history.push(command);
+        if (this.history.length > this.maxSize) {
+            this.history.shift();
+        }
+        this.historyIndex = -1;
+        this.tempInput = '';
+    }
+    navigateUp(currentInput) {
+        if (this.history.length === 0)
+            return null;
+        if (this.historyIndex === -1) {
+            this.tempInput = currentInput;
+            this.historyIndex = this.history.length - 1;
+        }
+        else if (this.historyIndex > 0) {
+            this.historyIndex--;
+        }
+        return this.history[this.historyIndex];
+    }
+    navigateDown() {
+        if (this.historyIndex === -1)
+            return null;
+        if (this.historyIndex < this.history.length - 1) {
+            this.historyIndex++;
+            return this.history[this.historyIndex];
+        }
+        else {
+            this.historyIndex = -1;
+            return this.tempInput;
+        }
+    }
+    reset() {
+        this.historyIndex = -1;
+        this.tempInput = '';
+    }
+    getAll() {
+        return [...this.history];
+    }
+    clear() {
+        this.history = [];
+        this.historyIndex = -1;
+        this.tempInput = '';
+    }
+    setHistory(history) {
+        this.history = history.slice(-this.maxSize);
+        this.historyIndex = -1;
+    }
+}
+
+class CommandRegistry {
+    constructor() {
+        this.commands = new Map();
+        this.aliases = new Map();
+    }
+    register(definition) {
+        this.commands.set(definition.name, definition);
+        if (definition.aliases) {
+            definition.aliases.forEach(alias => {
+                this.aliases.set(alias, definition.name);
+            });
+        }
+    }
+    registerSimple(name, handler, description) {
+        this.register({
+            name,
+            handler,
+            description,
+        });
+    }
+    unregister(name) {
+        const command = this.commands.get(name);
+        if (!command)
+            return false;
+        if (command.aliases) {
+            command.aliases.forEach(alias => {
+                this.aliases.delete(alias);
+            });
+        }
+        return this.commands.delete(name);
+    }
+    get(name) {
+        const commandName = this.aliases.get(name) || name;
+        return this.commands.get(commandName);
+    }
+    has(name) {
+        return this.commands.has(name) || this.aliases.has(name);
+    }
+    getAll() {
+        return Array.from(this.commands.values());
+    }
+    getNames() {
+        return Array.from(this.commands.keys());
+    }
+    parseInput(input) {
+        const parts = this.tokenize(input);
+        const command = parts[0] || '';
+        const args = [];
+        const flags = {};
+        for (let i = 1; i < parts.length; i++) {
+            const part = parts[i];
+            if (part.startsWith('--')) {
+                const [key, value] = part.slice(2).split('=');
+                flags[key] = value !== undefined ? value : true;
+            }
+            else if (part.startsWith('-') && part.length === 2) {
+                flags[part.slice(1)] = true;
+            }
+            else {
+                args.push(part);
+            }
+        }
+        return { command, args, flags };
+    }
+    tokenize(input) {
+        const tokens = [];
+        let current = '';
+        let inQuote = false;
+        let quoteChar = '';
+        for (let i = 0; i < input.length; i++) {
+            const char = input[i];
+            if ((char === '"' || char === "'") && !inQuote) {
+                inQuote = true;
+                quoteChar = char;
+            }
+            else if (char === quoteChar && inQuote) {
+                inQuote = false;
+                quoteChar = '';
+            }
+            else if (char === ' ' && !inQuote) {
+                if (current) {
+                    tokens.push(current);
+                    current = '';
+                }
+            }
+            else {
+                current += char;
+            }
+        }
+        if (current) {
+            tokens.push(current);
+        }
+        return tokens;
+    }
+}
+
+class OutputManager {
+    constructor(container, maxLines = 1000) {
+        this.container = container;
+        this.maxLines = maxLines;
+        this.outputElement = document.createElement('div');
+        this.outputElement.className = 'terminal-output';
+        this.container.appendChild(this.outputElement);
+    }
+    write(text, options = {}) {
+        const span = document.createElement('span');
+        if (options.html) {
+            span.innerHTML = text;
+        }
+        else {
+            span.textContent = text;
+        }
+        this.applyStyles(span, options);
+        this.outputElement.appendChild(span);
+        this.trimOutput();
+        this.scrollToBottom();
+        return span;
+    }
+    writeln(text, options = {}) {
+        const div = document.createElement('div');
+        div.className = 'terminal-history-line';
+        if (options.html) {
+            div.innerHTML = text;
+        }
+        else {
+            div.textContent = text;
+        }
+        this.applyStyles(div, options);
+        this.outputElement.appendChild(div);
+        this.trimOutput();
+        this.scrollToBottom();
+        return div;
+    }
+    writeCommand(prompt, command) {
+        const line = document.createElement('div');
+        line.className = 'terminal-line terminal-history-line';
+        const promptSpan = document.createElement('span');
+        promptSpan.className = 'terminal-prompt';
+        promptSpan.textContent = prompt;
+        const commandSpan = document.createElement('span');
+        commandSpan.textContent = command;
+        line.appendChild(promptSpan);
+        line.appendChild(commandSpan);
+        this.outputElement.appendChild(line);
+        this.trimOutput();
+        this.scrollToBottom();
+    }
+    writeError(text) {
+        return this.writeln(text, { color: 'inherit', className: 'terminal-error' });
+    }
+    writeSuccess(text) {
+        return this.writeln(text, { color: 'inherit', className: 'terminal-success' });
+    }
+    writeWarning(text) {
+        return this.writeln(text, { color: 'inherit', className: 'terminal-warning' });
+    }
+    writeInfo(text) {
+        return this.writeln(text, { color: 'inherit', className: 'terminal-info' });
+    }
+    writeTable(data, columns) {
+        if (data.length === 0)
+            return;
+        const cols = columns || Object.keys(data[0]);
+        const widths = {};
+        // Calculate column widths
+        cols.forEach(col => {
+            widths[col] = col.length;
+            data.forEach(row => {
+                const val = String(row[col] ?? '');
+                widths[col] = Math.max(widths[col], val.length);
+            });
+        });
+        // Header
+        const header = cols.map(col => col.padEnd(widths[col])).join(' | ');
+        const separator = cols.map(col => '-'.repeat(widths[col])).join('-+-');
+        this.writeln(header);
+        this.writeln(separator);
+        // Rows
+        data.forEach(row => {
+            const line = cols.map(col => String(row[col] ?? '').padEnd(widths[col])).join(' | ');
+            this.writeln(line);
+        });
+    }
+    clear() {
+        this.outputElement.innerHTML = '';
+    }
+    applyStyles(element, options) {
+        if (options.color) {
+            element.style.color = options.color;
+        }
+        if (options.backgroundColor) {
+            element.style.backgroundColor = options.backgroundColor;
+        }
+        if (options.bold) {
+            element.classList.add('text-bold');
+        }
+        if (options.italic) {
+            element.classList.add('text-italic');
+        }
+        if (options.underline) {
+            element.classList.add('text-underline');
+        }
+        if (options.className) {
+            element.classList.add(options.className);
+        }
+    }
+    trimOutput() {
+        const lines = this.outputElement.children;
+        while (lines.length > this.maxLines) {
+            this.outputElement.removeChild(lines[0]);
+        }
+    }
+    scrollToBottom() {
+        this.container.scrollTop = this.container.scrollHeight;
+    }
+    getElement() {
+        return this.outputElement;
+    }
+}
+
+class Terminal {
+    constructor(options) {
+        this.isEnabled = true;
+        this.eventListeners = new Map();
+        this.terminalId = `terminal-${Math.random().toString(36).substr(2, 9)}`;
+        // Get container
+        if (typeof options.container === 'string') {
+            const el = document.querySelector(options.container);
+            if (!el)
+                throw new Error(`Container not found: ${options.container}`);
+            this.container = el;
+        }
+        else {
+            this.container = options.container;
+        }
+        // Set default options
+        this.options = {
+            container: this.container,
+            prompt: options.prompt ?? '$ ',
+            welcomeMessage: options.welcomeMessage ?? '',
+            theme: options.theme ?? 'default',
+            fontSize: options.fontSize ?? 14,
+            fontFamily: options.fontFamily ?? "'Cascadia Code', 'Fira Code', Consolas, monospace",
+            cursorStyle: options.cursorStyle ?? 'block',
+            cursorBlink: options.cursorBlink ?? true,
+            history: options.history ?? true,
+            historySize: options.historySize ?? 100,
+            autoFocus: options.autoFocus ?? true,
+            scrollback: options.scrollback ?? 1000,
+            tabSize: options.tabSize ?? 4,
+        };
+        this.theme = getTheme(this.options.theme);
+        this.history = new HistoryManager(this.options.historySize);
+        this.commands = new CommandRegistry();
+        this.init();
+        this.output = new OutputManager(this.container, this.options.scrollback);
+        this.createInputLine();
+        this.registerBuiltInCommands();
+        this.showWelcomeMessage();
+        this.emit('ready');
+    }
+    init() {
+        this.container.id = this.terminalId;
+        this.container.innerHTML = '';
+        // Inject styles
+        this.styleElement = document.createElement('style');
+        this.styleElement.textContent = generateStyles(this.terminalId, this.theme, this.options);
+        document.head.appendChild(this.styleElement);
+        // Click to focus
+        this.container.addEventListener('click', () => {
+            if (this.isEnabled) {
+                this.focus();
+            }
+        });
+    }
+    createInputLine() {
+        this.inputLine = document.createElement('div');
+        this.inputLine.className = 'terminal-line';
+        this.promptElement = document.createElement('span');
+        this.promptElement.className = 'terminal-prompt';
+        this.promptElement.textContent = this.options.prompt;
+        const inputWrapper = document.createElement('div');
+        inputWrapper.className = 'terminal-input-wrapper';
+        this.inputElement = document.createElement('input');
+        this.inputElement.type = 'text';
+        this.inputElement.className = 'terminal-input';
+        this.inputElement.spellcheck = false;
+        this.inputElement.autocomplete = 'off';
+        this.inputElement.autocapitalize = 'off';
+        this.cursorElement = document.createElement('span');
+        this.cursorElement.className = 'terminal-cursor';
+        inputWrapper.appendChild(this.inputElement);
+        inputWrapper.appendChild(this.cursorElement);
+        this.inputLine.appendChild(this.promptElement);
+        this.inputLine.appendChild(inputWrapper);
+        this.container.appendChild(this.inputLine);
+        this.setupInputHandlers();
+        this.updateCursor();
+        if (this.options.autoFocus) {
+            this.focus();
+        }
+    }
+    setupInputHandlers() {
+        this.inputElement.addEventListener('input', () => {
+            this.updateCursor();
+            this.emit('input', this.inputElement.value);
+        });
+        this.inputElement.addEventListener('keydown', (e) => {
+            this.emit('key', e);
+            this.handleKeyDown(e);
+        });
+        this.inputElement.addEventListener('blur', () => {
+            this.cursorElement.style.display = 'none';
+        });
+        this.inputElement.addEventListener('focus', () => {
+            this.cursorElement.style.display = 'inline-block';
+        });
+    }
+    handleKeyDown(e) {
+        switch (e.key) {
+            case 'Enter':
+                e.preventDefault();
+                this.executeCurrentInput();
+                break;
+            case 'ArrowUp':
+                e.preventDefault();
+                if (this.options.history) {
+                    const prev = this.history.navigateUp(this.inputElement.value);
+                    if (prev !== null) {
+                        this.inputElement.value = prev;
+                        this.updateCursor();
+                        // Move cursor to end
+                        setTimeout(() => {
+                            this.inputElement.selectionStart = this.inputElement.selectionEnd = this.inputElement.value.length;
+                        }, 0);
+                    }
+                }
+                break;
+            case 'ArrowDown':
+                e.preventDefault();
+                if (this.options.history) {
+                    const next = this.history.navigateDown();
+                    if (next !== null) {
+                        this.inputElement.value = next;
+                        this.updateCursor();
+                    }
+                }
+                break;
+            case 'Tab':
+                e.preventDefault();
+                this.handleTabCompletion();
+                break;
+            case 'c':
+                if (e.ctrlKey) {
+                    e.preventDefault();
+                    this.output.writeCommand(this.options.prompt, this.inputElement.value + '^C');
+                    this.inputElement.value = '';
+                    this.updateCursor();
+                    this.history.reset();
+                }
+                break;
+            case 'l':
+                if (e.ctrlKey) {
+                    e.preventDefault();
+                    this.clear();
+                }
+                break;
+            case 'u':
+                if (e.ctrlKey) {
+                    e.preventDefault();
+                    this.inputElement.value = '';
+                    this.updateCursor();
+                }
+                break;
+        }
+    }
+    handleTabCompletion() {
+        const input = this.inputElement.value;
+        const parts = input.split(' ');
+        if (parts.length === 1) {
+            // Command completion
+            const partial = parts[0].toLowerCase();
+            const matches = this.commands.getNames().filter(name => name.toLowerCase().startsWith(partial));
+            if (matches.length === 1) {
+                this.inputElement.value = matches[0] + ' ';
+                this.updateCursor();
+            }
+            else if (matches.length > 1) {
+                this.output.writeCommand(this.options.prompt, input);
+                this.output.writeln(matches.join('  '));
+            }
+        }
+    }
+    async executeCurrentInput() {
+        const input = this.inputElement.value.trim();
+        // Show the command in output
+        this.output.writeCommand(this.options.prompt, this.inputElement.value);
+        // Clear input
+        this.inputElement.value = '';
+        this.updateCursor();
+        if (!input)
+            return;
+        // Add to history
+        if (this.options.history) {
+            this.history.add(input);
+        }
+        // Parse and execute
+        const { command, args, flags } = this.commands.parseInput(input);
+        this.emit('command', command, args);
+        const commandDef = this.commands.get(command);
+        if (commandDef) {
+            try {
+                const context = {
+                    terminal: this.getInterface(),
+                    args,
+                    rawInput: input,
+                    flags,
+                };
+                const result = await commandDef.handler(context);
+                if (typeof result === 'string') {
+                    this.output.writeln(result);
+                }
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                this.output.writeError(`Error: ${message}`);
+            }
+        }
+        else if (command) {
+            this.output.writeError(`Command not found: ${command}`);
+            this.output.writeln("Type 'help' for available commands.");
+        }
+        this.output.scrollToBottom();
+    }
+    updateCursor() {
+        const text = this.inputElement.value;
+        const selectionStart = this.inputElement.selectionStart || 0;
+        // Create a temporary span to measure text width
+        const measurer = document.createElement('span');
+        measurer.style.font = getComputedStyle(this.inputElement).font;
+        measurer.style.visibility = 'hidden';
+        measurer.style.position = 'absolute';
+        measurer.style.whiteSpace = 'pre';
+        measurer.textContent = text.substring(0, selectionStart);
+        document.body.appendChild(measurer);
+        const width = measurer.offsetWidth;
+        document.body.removeChild(measurer);
+        this.cursorElement.style.left = `${width}px`;
+    }
+    showWelcomeMessage() {
+        const message = this.options.welcomeMessage;
+        if (!message)
+            return;
+        if (Array.isArray(message)) {
+            message.forEach(line => this.output.writeln(line));
+        }
+        else {
+            this.output.writeln(message);
+        }
+    }
+    registerBuiltInCommands() {
+        // Help command
+        this.commands.register({
+            name: 'help',
+            description: 'Show available commands',
+            aliases: ['?', 'commands'],
+            handler: ({ args }) => {
+                if (args.length > 0) {
+                    const cmd = this.commands.get(args[0]);
+                    if (cmd) {
+                        this.output.writeln(`${cmd.name}: ${cmd.description || 'No description'}`);
+                        if (cmd.usage) {
+                            this.output.writeln(`Usage: ${cmd.usage}`);
+                        }
+                        if (cmd.aliases && cmd.aliases.length > 0) {
+                            this.output.writeln(`Aliases: ${cmd.aliases.join(', ')}`);
+                        }
+                    }
+                    else {
+                        this.output.writeError(`Unknown command: ${args[0]}`);
+                    }
+                }
+                else {
+                    this.output.writeln('Available commands:');
+                    this.output.writeln('');
+                    const commands = this.commands.getAll();
+                    const maxLength = Math.max(...commands.map(c => c.name.length));
+                    commands.forEach(cmd => {
+                        const name = cmd.name.padEnd(maxLength + 2);
+                        const desc = cmd.description || '';
+                        this.output.writeln(`  ${name}${desc}`);
+                    });
+                }
+            },
+        });
+        // Clear command
+        this.commands.register({
+            name: 'clear',
+            description: 'Clear the terminal',
+            aliases: ['cls'],
+            handler: () => {
+                this.clear();
+            },
+        });
+        // History command
+        this.commands.register({
+            name: 'history',
+            description: 'Show command history',
+            handler: () => {
+                const hist = this.history.getAll();
+                if (hist.length === 0) {
+                    this.output.writeln('No history');
+                }
+                else {
+                    hist.forEach((cmd, i) => {
+                        this.output.writeln(`  ${(i + 1).toString().padStart(4)}  ${cmd}`);
+                    });
+                }
+            },
+        });
+        // Echo command
+        this.commands.register({
+            name: 'echo',
+            description: 'Print text to the terminal',
+            usage: 'echo <text>',
+            handler: ({ args }) => {
+                return args.join(' ');
+            },
+        });
+    }
+    getInterface() {
+        return {
+            write: (text, options) => this.write(text, options),
+            writeln: (text, options) => this.writeln(text, options),
+            clear: () => this.clear(),
+            setPrompt: (prompt) => this.setPrompt(prompt),
+            focus: () => this.focus(),
+            blur: () => this.blur(),
+            disable: () => this.disable(),
+            enable: () => this.enable(),
+            getHistory: () => this.history.getAll(),
+            destroy: () => this.destroy(),
+        };
+    }
+    // Public API
+    write(text, options) {
+        this.output.write(text, options);
+    }
+    writeln(text, options) {
+        this.output.writeln(text, options);
+    }
+    writeError(text) {
+        this.output.writeError(text);
+    }
+    writeSuccess(text) {
+        this.output.writeSuccess(text);
+    }
+    writeWarning(text) {
+        this.output.writeWarning(text);
+    }
+    writeInfo(text) {
+        this.output.writeInfo(text);
+    }
+    writeTable(data, columns) {
+        this.output.writeTable(data, columns);
+    }
+    clear() {
+        this.output.clear();
+        this.emit('clear');
+    }
+    focus() {
+        this.inputElement.focus();
+    }
+    blur() {
+        this.inputElement.blur();
+    }
+    disable() {
+        this.isEnabled = false;
+        this.inputElement.disabled = true;
+        this.container.classList.add('terminal-disabled');
+    }
+    enable() {
+        this.isEnabled = true;
+        this.inputElement.disabled = false;
+        this.container.classList.remove('terminal-disabled');
+    }
+    setPrompt(prompt) {
+        this.options.prompt = prompt;
+        this.promptElement.textContent = prompt;
+    }
+    getPrompt() {
+        return this.options.prompt;
+    }
+    setValue(value) {
+        this.inputElement.value = value;
+        this.updateCursor();
+    }
+    getValue() {
+        return this.inputElement.value;
+    }
+    // Command registration
+    registerCommand(definition) {
+        this.commands.register(definition);
+    }
+    registerCommands(definitions) {
+        definitions.forEach(def => this.commands.register(def));
+    }
+    addCommand(name, handler, description) {
+        this.commands.registerSimple(name, handler, description);
+    }
+    removeCommand(name) {
+        return this.commands.unregister(name);
+    }
+    hasCommand(name) {
+        return this.commands.has(name);
+    }
+    getCommands() {
+        return this.commands.getAll();
+    }
+    // Execute command programmatically
+    async exec(command) {
+        const originalValue = this.inputElement.value;
+        this.inputElement.value = command;
+        await this.executeCurrentInput();
+        this.inputElement.value = originalValue;
+    }
+    // Theme
+    setTheme(theme) {
+        this.theme = typeof theme === 'string' ? getTheme(theme) : theme;
+        this.styleElement.textContent = generateStyles(this.terminalId, this.theme, this.options);
+    }
+    getTheme() {
+        return { ...this.theme };
+    }
+    // History
+    getHistory() {
+        return this.history.getAll();
+    }
+    clearHistory() {
+        this.history.clear();
+    }
+    setHistory(history) {
+        this.history.setHistory(history);
+    }
+    // Events
+    on(event, callback) {
+        if (!this.eventListeners.has(event)) {
+            this.eventListeners.set(event, new Set());
+        }
+        this.eventListeners.get(event).add(callback);
+    }
+    off(event, callback) {
+        this.eventListeners.get(event)?.delete(callback);
+    }
+    emit(event, ...args) {
+        this.eventListeners.get(event)?.forEach(callback => {
+            try {
+                callback(...args);
+            }
+            catch (e) {
+                console.error('Event listener error:', e);
+            }
+        });
+    }
+    // Cleanup
+    destroy() {
+        this.styleElement.remove();
+        this.container.innerHTML = '';
+        this.eventListeners.clear();
+    }
+}
+
+export { CommandRegistry, HistoryManager, OutputManager, Terminal, Terminal as default, getTheme, themes };
+//# sourceMappingURL=index.esm.js.map