@pugi/cli 0.1.0-beta.44 → 0.1.0-beta.46

package/dist/runtime/version.js

@@ -44,7 +44,7 @@ export function sanitizeSemver(raw) {
  * during import). When bumping the CLI version BOTH literals must be
  * updated; the release smoke-test (`pack:smoke`) verifies they agree.
  */
-export const PUGI_CLI_VERSION = sanitizeSemver('0.1.0-beta.44');
+export const PUGI_CLI_VERSION = sanitizeSemver('0.1.0-beta.46');
 /**
  * Outbound: the CLI's installed semver. Read at request time by
  * `version-interceptor.ts` and injected on every `fetch` call.

package/dist/tui/input-box.js

@@ -238,7 +238,9 @@ export function InputBox(props) {
                 setCursor(draftBeforeSearch.length);
                 return;
             }
-            if (key.return) {
+            // Bare LF accepts the focused match, same as CR (`key.return`).
+            // See the post-search block below for the rationale.
+            if (key.return || (input === '\n' && !key.meta && !key.ctrl && !key.shift)) {
                 const picked = currentBrief(search);
                 setSearch(undefined);
                 if (picked !== null) {
@@ -257,6 +259,11 @@ export function InputBox(props) {
                 return;
             }
             if (input && !key.meta && !key.ctrl) {
+                // Drop a bare LF from the search query — the Enter-accept
+                // branch above already handled it; falling through here would
+                // splice a newline into the search string.
+                if (input === '\n')
+                    return;
                 const nextQuery = search.query + input;
                 setSearch(applyQuery(search, nextQuery, history));
                 return;
@@ -279,6 +286,118 @@ export function InputBox(props) {
             setSearch(initialSearchState(history));
             return;
         }
+        // P0 fix (CEO 2026-05-29 dogfood, second iteration): bare LF (`\n`)
+        // MUST submit the brief, same as bare CR (`\r`). Ink's parseKeypress
+        // maps `\r` to `key.return` and `\n` to `key.name === 'enter'`
+        // WITHOUT setting `key.return`. Most real terminals deliver CR for
+        // Enter (ICRNL on by default), so the `key.return` branch below
+        // catches them. But when stdin is a PTY whose parent writes raw
+        // `\n` (Python's `pty.fork` + `os.write(fd, b"\n")`, automation
+        // harnesses, certain SSH multiplexers), the LF arrives as a
+        // printable char.
+        //
+        // PR #697 (beta.45) fixed the case where `input === '\n'` exactly.
+        // CEO PTY smoke 2026-05-29 surfaced the REAL shape: when the parent
+        // writes the brief AND the Enter as separate `os.write` calls (or
+        // even when it doesn't), Node's stdin buffer COALESCES them into
+        // ONE chunk before Ink delivers the `useInput` event. The repro
+        // confirmed via stderr instrumentation: typing `hi\n` arrives in
+        // input-box as `bytes=[68 69 0a] len=3 flags=-` — a SINGLE 3-char
+        // chunk "hi\n" with no key flags. The PR #697 branch (`input ===
+        // '\n'`) does not match, so `hi\n` falls through to the printable-
+        // char branch and the literal newline lands in the buffer as
+        // `› hi\n  █` (multi-line composer, brief never dispatches, status
+        // stays `idle` forever).
+        //
+        // Fix: detect a TRAILING `\n` in a printable chunk with no
+        // modifiers — type the prefix into the buffer, then submit. The
+        // discriminator that keeps multi-line paste working: the chunk
+        // must contain EXACTLY ONE `\n` (the trailing one) and no other
+        // newlines. Multi-line pastes have ≥2 `\n` characters (or arrive
+        // wrapped in bracketed-paste markers handled below), so they
+        // still preserve interior newlines via the printable-char branch.
+        //
+        // Detection contract:
+        //   - `input` ends with `\n`
+        //   - no Ctrl / Meta / Shift modifiers
+        //   - exactly ONE `\n` in the chunk (the trailing one)
+        //   - chunk is not bracketed-paste wrapped (markers stripped below)
+        //
+        // Edge cases covered by `test/input-box-lf-submit.spec.tsx`:
+        //   - bare `\n`                  → submit empty (no-op on empty buf)
+        //   - `hi\n`                     → splice `hi` + submit
+        //   - `hi\nthere\n` (multi-line) → printable branch, preserves \n
+        //   - `\r` (CR)                  → key.return branch unchanged
+        //   - `hi\r\n` (CRLF)            → key.return branch (CR wins first)
+        const endsWithLf = input.length > 0 && input.charCodeAt(input.length - 1) === 0x0a;
+        const newlineCount = (input.match(/\n/g) || []).length;
+        if (endsWithLf
+            && newlineCount === 1
+            && !key.meta
+            && !key.ctrl
+            && !key.shift) {
+            // Splice the prefix (everything before the trailing `\n`) into
+            // the buffer at the cursor, then run the canonical submit path.
+            // Refs (cursorRef / lineRef) hold the latest committed values so
+            // the splice runs against the operator's most recent edits even
+            // if a previous async paste / setState is still mid-flight.
+            const prefix = input.slice(0, -1);
+            let mergedLine = lineRef.current;
+            let mergedCursor = cursorRef.current;
+            if (prefix.length > 0) {
+                // Same sanitisation as the printable-char branch below — strip
+                // bracketed-paste markers so a stray escape sequence never
+                // lands in the submitted brief.
+                const stripped = prefix
+                    .replace(/\x1b\[200~/g, '')
+                    .replace(/\x1b\[201~/g, '')
+                    .replace(/\[200~/g, '')
+                    .replace(/\[201~/g, '');
+                if (stripped.length > 0) {
+                    mergedLine =
+                        mergedLine.slice(0, mergedCursor) + stripped + mergedLine.slice(mergedCursor);
+                    mergedCursor = mergedCursor + stripped.length;
+                }
+            }
+            // Synthesise the same payload-shape the `key.return` branch
+            // below uses so palette completion + history dedup + onSubmit
+            // dispatch all run identically.
+            const paletteHere = !paletteSuppressed
+                ? filterPalette(mergedLine)
+                : { rows: [], totalBeforeLimit: 0 };
+            const paletteOpenHere = paletteHere.rows.length > 0;
+            const paletteFocusedIndexHere = paletteHere.rows.length === 0
+                ? 0
+                : Math.min(paletteIndex, paletteHere.rows.length - 1);
+            let payload = mergedLine;
+            if (paletteOpenHere) {
+                const completed = completePalette(mergedLine, paletteHere.rows, paletteFocusedIndexHere);
+                if (completed !== null)
+                    payload = completed;
+            }
+            const trimmed = payload.trim();
+            if (trimmed.length > 0) {
+                setHistory((prev) => {
+                    if (prev[prev.length - 1] === trimmed)
+                        return prev;
+                    return [...prev, trimmed];
+                });
+                setHistoryIndex(-1);
+                if (props.workspaceSlug) {
+                    appendHistory({
+                        home: props.historyHome,
+                        workspaceSlug: props.workspaceSlug,
+                        brief: trimmed,
+                    });
+                }
+                props.onSubmit(trimmed);
+            }
+            setLine('');
+            setCursor(0);
+            setPaletteSuppressed(false);
+            setPaletteIndex(0);
+            return;
+        }
         // Readline-style kill ring shortcuts. All four kills push the
         // removed slice onto the ring; Ctrl+Y yanks the most recent.
         if (key.ctrl && input === 'u') {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pugi/cli",
-  "version": "0.1.0-beta.44",
+  "version": "0.1.0-beta.46",
   "description": "Pugi CLI - terminal-native software execution system",
   "homepage": "https://pugi.io",
   "repository": {
@@ -55,7 +55,7 @@
     "undici": "^8.3.0",
     "zod": "^3.23.0",
     "@pugi/personas": "0.1.2",
-    "@pugi/sdk": "0.1.0-beta.44"
+    "@pugi/sdk": "0.1.0-beta.46"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",