@levu/snap 0.3.1 → 0.3.3

package/CHANGELOG.md

@@ -5,6 +5,20 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.3.3] - 2026-02-26
+
+### Fixed
+- Added a robust `Shift+Enter` fallback for Ghostty/macOS when terminals emit literal suffix tokens like `13~` via line events without keypress modifiers.
+- Kept `Enter` submit behavior intact while allowing newline insertion from both keypress and fallback sequence paths.
+- Replaced raw `@clack/prompts` password rendering with a stable raw-mode password input path to avoid visual cursor/glyph jitter (including the 3-character middle-glyph jump case).
+- Added regression tests for Ghostty `13~` fallback handling and password input behavior.
+
+## [0.3.2] - 2026-02-26
+
+### Fixed
+- Added Ghostty macOS fallback handling for `Shift+Enter` escape sequence variants like `13~`, so multiline prompts insert newline instead of echoing sequence text.
+- Added regression coverage for the `13~` modified-enter sequence path.
+
 ## [0.3.1] - 2026-02-26
 
 ### Fixed

package/dist/tui/component-adapters/multiline-text.js

@@ -28,6 +28,7 @@ export const createMultilineTextPrompt = () => {
             let rawModeEnabled = false;
             let keypressListener;
             let ignoreNextLineEvent = false;
+            let expectingGhosttySequenceEcho = false;
             const cleanup = () => {
                 if (keypressListener) {
                     input.off('keypress', keypressListener);
@@ -62,6 +63,46 @@ export const createMultilineTextPrompt = () => {
                     return rlLine;
                 return currentLine;
             };
+            const isGhosttyShiftEnter = (str, key) => {
+                const sequence = String(key?.sequence ?? '');
+                if (sequence.includes('[13;2u'))
+                    return true;
+                if (sequence.includes('[27;2;13~'))
+                    return true;
+                if (sequence.endsWith('13~'))
+                    return true;
+                if (sequence === '13~')
+                    return true;
+                if (str === '~13')
+                    return true;
+                if (str === '13~')
+                    return true;
+                if (str === '\u001b[13;2u')
+                    return true;
+                return false;
+            };
+            const stripGhosttyShiftEnterSuffix = (line) => {
+                const suffixes = [
+                    '\u001b[13;2u',
+                    '[13;2u',
+                    '\u001b[27;2;13~',
+                    '[27;2;13~',
+                    '13~',
+                    '~13'
+                ];
+                for (const suffix of suffixes) {
+                    if (line.endsWith(suffix)) {
+                        return line.slice(0, -suffix.length);
+                    }
+                }
+                return null;
+            };
+            const insertNewline = () => {
+                lines.push(getLiveLine());
+                currentLine = '';
+                rl.line = '';
+                output.write(`\n${pc.dim('> ')}`);
+            };
             const showPrompt = () => {
                 output.write(`\n${pc.dim('> ')}${currentLine}`);
             };
@@ -109,6 +150,23 @@ export const createMultilineTextPrompt = () => {
                     ignoreNextLineEvent = false;
                     return;
                 }
+                if (expectingGhosttySequenceEcho) {
+                    if (line === '13~' || line === '~13' || line === '[13;2u' || line === '\u001b[13;2u') {
+                        expectingGhosttySequenceEcho = false;
+                        return;
+                    }
+                    expectingGhosttySequenceEcho = false;
+                }
+                // Some terminals (notably Ghostty on macOS) may emit Shift+Enter as literal
+                // suffix text like "13~" without keypress modifier metadata.
+                const ghosttySuffixTrimmedLine = stripGhosttyShiftEnterSuffix(line);
+                if (ghosttySuffixTrimmedLine !== null) {
+                    lines.push(ghosttySuffixTrimmedLine);
+                    currentLine = '';
+                    rl.line = '';
+                    showPrompt();
+                    return;
+                }
                 const now = Date.now();
                 // Check for double Enter to submit
                 if (line === '' && now - lastEnterTime < DOUBLE_ENTER_TIMEOUT) {
@@ -171,14 +229,15 @@ export const createMultilineTextPrompt = () => {
                             output.write(`${pc.dim('> ')}${currentLine}`);
                         }
                     }
+                    else if (isGhosttyShiftEnter(str, key)) {
+                        expectingGhosttySequenceEcho = true;
+                        insertNewline();
+                    }
                     else if (key.name === 'enter' || key.name === 'return') {
                         ignoreNextLineEvent = true;
                         if (key.shift || key.alt) {
                             // Shift+Enter / Alt+Enter inserts a new line.
-                            lines.push(getLiveLine());
-                            currentLine = '';
-                            rl.line = '';
-                            output.write(`\n${pc.dim('> ')}`);
+                            insertNewline();
                             return;
                         }
                         submit(lines.concat(getLiveLine()).join('\n'));

package/dist/tui/component-adapters/password.d.ts

@@ -1,7 +1,11 @@
+import type { Readable, Writable } from 'node:stream';
 export interface PasswordPromptInput {
     message: string;
     required?: boolean;
     validate?: (value: string) => string | Error | undefined;
     mask?: string;
+    input?: Readable;
+    output?: Writable;
+    signal?: AbortSignal;
 }
 export declare const runPasswordPrompt: (input: PasswordPromptInput) => Promise<string>;

package/dist/tui/component-adapters/password.js

@@ -1,8 +1,12 @@
 import { password as clackPassword } from '@clack/prompts';
-import { isInteractiveTerminal } from './readline-utils.js';
-import { unwrapClackResult } from './cancel.js';
+import { emitKeypressEvents } from 'node:readline';
+import * as pc from 'picocolors';
+import { PromptCancelledError, unwrapClackResult } from './cancel.js';
 export const runPasswordPrompt = async (input) => {
-    if (!isInteractiveTerminal()) {
+    const inStream = (input.input ?? process.stdin);
+    const outStream = (input.output ?? process.stdout);
+    const isInteractive = Boolean(inStream?.isTTY && outStream?.isTTY);
+    if (!isInteractive) {
         // For non-interactive terminals, read from stdin in a secure way
         // or return empty/throw error
         if (input.required) {
@@ -10,15 +14,104 @@ export const runPasswordPrompt = async (input) => {
         }
         return '';
     }
-    const value = await clackPassword({
-        message: input.message,
-        mask: input.mask ?? '•',
-        validate: (raw) => {
-            if (input.required && (!raw || raw.trim().length === 0)) {
-                return `Password is required`;
-            }
-            return input.validate?.(raw ?? '');
+    const mask = input.mask && input.mask.length > 0 ? input.mask : '*';
+    const validateValue = (value) => {
+        if (input.required && value.trim().length === 0) {
+            return 'Password is required';
+        }
+        const result = input.validate?.(value);
+        if (!result)
+            return undefined;
+        return result instanceof Error ? result.message : String(result);
+    };
+    // Fallback to clack implementation if raw mode is unavailable.
+    if (typeof inStream.setRawMode !== 'function') {
+        const value = await clackPassword({
+            message: input.message,
+            mask,
+            validate: (raw) => validateValue(raw ?? ''),
+            input: inStream,
+            output: outStream,
+            signal: input.signal
+        });
+        return unwrapClackResult(value);
+    }
+    const value = await new Promise((resolve, reject) => {
+        let password = '';
+        let rawModeEnabled = false;
+        let keypressListener;
+        const clearLine = () => {
+            outStream.write('\r\x1b[2K');
+        };
+        const render = () => {
+            clearLine();
+            outStream.write(`${pc.dim('> ')}${mask.repeat(password.length)}`);
+        };
+        const cleanup = () => {
+            if (keypressListener && typeof inStream.off === 'function') {
+                inStream.off('keypress', keypressListener);
+            }
+            if (rawModeEnabled) {
+                inStream.setRawMode?.(false);
+                rawModeEnabled = false;
+            }
+        };
+        const cancel = () => {
+            cleanup();
+            reject(new PromptCancelledError('Cancelled by user.'));
+        };
+        const submit = () => {
+            const validationError = validateValue(password);
+            if (validationError) {
+                outStream.write(`\n${pc.yellow('!')} ${validationError}\n`);
+                render();
+                return;
+            }
+            cleanup();
+            outStream.write('\n');
+            resolve(password);
+        };
+        outStream.write(`\n${pc.cyan('○')} ${pc.bold(input.message)}\n`);
+        outStream.write(`${pc.dim('> ')}`);
+        emitKeypressEvents(inStream);
+        inStream.setRawMode?.(true);
+        rawModeEnabled = true;
+        inStream.resume?.();
+        keypressListener = (str, key) => {
+            if (key?.ctrl && key.name === 'c') {
+                cancel();
+                return;
+            }
+            if (key?.name === 'escape') {
+                cancel();
+                return;
+            }
+            if (key?.name === 'enter' || key?.name === 'return') {
+                submit();
+                return;
+            }
+            if (key?.name === 'backspace') {
+                if (password.length > 0) {
+                    password = password.slice(0, -1);
+                    render();
+                }
+                return;
+            }
+            if (key?.ctrl || key?.meta) {
+                return;
+            }
+            if (!str || /[\u0000-\u001f\u007f]/.test(str)) {
+                return;
+            }
+            password += str;
+            render();
+        };
+        inStream.on('keypress', keypressListener);
+        if (input.signal) {
+            input.signal.addEventListener('abort', () => {
+                cancel();
+            }, { once: true });
         }
     });
-    return unwrapClackResult(value);
+    return value;
 };

package/docs/component-reference.md

@@ -58,7 +58,7 @@ When `paste` is enabled, users can paste from clipboard using:
 
 Multi-line paste is automatically supported. Keyboard behavior:
 - `Enter` submits input
-- `Shift+Enter` inserts a newline (when your terminal reports Shift modifiers)
+- `Shift+Enter` inserts a newline (including Ghostty/macOS fallback sequences like `13~`)
 - `Alt+Enter` inserts a newline fallback
 
 ### confirm

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@levu/snap",
-  "version": "0.3.1",
+  "version": "0.3.3",
   "type": "module",
   "bin": {
     "snap": "./dist/cli-entry.js"