ispbills-icli 8.3.0 → 8.3.1

package/README.md

@@ -188,7 +188,7 @@ suggestion (accept with **Tab** or **→**), and runs the highlighted command on
 | **@** | Mention a device/entity (e.g. `@olt:`, `@onu:`); **Tab** / **→** completes the tag |
 | **↑/↓** (empty input) | Navigate input history |
 | **Ctrl+Z** / **Ctrl+Y** | Undo / redo the input line |
-| **Paste** | Multi-line pastes are inserted as one line (never auto-submitted) |
+| **Paste** | Multi-line pastes (incl. mouse right-click) keep their line breaks and are never auto-submitted — press **Enter** to send |
 | **Shift+Tab** | Toggle autopilot mode |
 | **Ctrl+T** | Toggle reasoning display |
 | **Ctrl+L** | Clear the transcript |
@@ -225,7 +225,7 @@ iCli connects to the same AI engine as the in-browser terminal:
 - **Bot memory** — `/remember` saves standing operator notes that are injected into every answer (`/memory`, `/forget` to manage)  
 - **Backups in git** — `/backup` archives config to a per-user git repo; run `/git status|log|commit|push` from the prompt  
 - **Share as a gist** — `/gist` publishes the last answer or transcript to a secret GitHub gist  
-- **Copy & paste** — `/copy` puts the last answer on the clipboard; multi-line pastes and **Ctrl+Z / Ctrl+Y** undo/redo work in the input  
+- **Copy & paste** — `/copy` puts the last answer on the clipboard; multi-line pastes (mouse right-click or Cmd/Ctrl+V) keep their line breaks, and **Ctrl+Z / Ctrl+Y** undo/redo work in the input  
 - **Full-screen terminal UI** — a full-height alternate-screen TUI (built on [Ink](https://github.com/vadimdemedes/ink)) with the banner pinned to the top, a bottom-pinned bordered input, a selectable slash-command menu, input history, and a bottom-anchored transcript — the same layout as GitHub Copilot CLI / Gemini CLI. Piped/non-interactive use falls back to plain streaming output  
 - **Terminal-aware rendering** — the layout reflows to your terminal width and resizes live; on classic Windows consoles (`cmd.exe` / legacy PowerShell) it auto-switches to ASCII-safe glyphs and borders so nothing shows as broken boxes  
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ispbills-icli",
-  "version": "8.3.0",
+  "version": "8.3.1",
   "description": "iCli — IspBills AI network engineer in your terminal",
   "keywords": [
     "ispbills",

package/src/tui/app.js

@@ -100,8 +100,9 @@ export function App({ cfg, display = {}, onExternal, onExit, initialQuestion })
   const lastAnswerRef = useRef('');    // most recent assistant answer (for /copy, /gist)
   const choiceActionRef = useRef(null); // action to run when a non-AI Choice is picked
 
-  // Enable terminal bracketed-paste so multi-line pastes arrive as one chunk
-  // (the Composer flattens them) instead of submitting on the first newline.
+  // Enable terminal bracketed-paste so multi-line pastes (mouse right-click or
+  // Cmd/Ctrl+V) arrive wrapped in markers as one block — the Composer inserts
+  // them with newlines preserved instead of submitting on the first newline.
   useEffect(() => {
     try { process.stdout.write('\x1b[?2004h'); } catch {}
     return () => { try { process.stdout.write('\x1b[?2004l'); } catch {} };

package/src/tui/composer.js

@@ -40,6 +40,26 @@ export function Composer({ onSubmit, busy, width = 80 }) {
     lastMut.current = kind;
   };
 
+  // Bracketed-paste assembly. A right-click / Cmd+V paste is wrapped by the
+  // terminal in \x1b[200~ … \x1b[201~ and can arrive split across several
+  // reads, so we buffer until the end marker before inserting.
+  const pasteRef = useRef({ active: false, buf: '' });
+
+  // Insert pasted text at the cursor, PRESERVING newlines so multi-line pastes
+  // (configs, logs) keep their structure. Tabs → 2 spaces; other control chars
+  // and the bracketed-paste markers are dropped.
+  const insertPaste = (raw) => {
+    const text = raw
+      .replace(/\x1b?\[20[01]~/g, '')
+      .replace(/\r\n?/g, '\n')
+      .replace(/\t/g, '  ')
+      .replace(/[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/g, '');
+    if (!text) return;
+    snapshot('paste');
+    setValue((v) => v.slice(0, cursor) + text + v.slice(cursor));
+    setCursor((c) => c + text.length);
+  };
+
   // Determine the token being typed at the cursor to drive the palette.
   const upto = value.slice(0, cursor);
   const tokStart = Math.max(upto.lastIndexOf(' '), upto.lastIndexOf('\n')) + 1;
@@ -79,6 +99,25 @@ export function Composer({ onSubmit, busy, width = 80 }) {
   useInput((input, key) => {
     if (busy) return; // ignore edits while a turn streams (App handles Ctrl+C/Esc)
 
+    // ── Bracketed paste (mouse right-click / Cmd+V), possibly split reads ──
+    // Ink strips the leading ESC, so the terminal's \x1b[200~ … \x1b[201~
+    // wrappers arrive as the marker text "[200~" / "[201~" (sometimes as their
+    // own useInput calls). Buffer everything between them so embedded newlines
+    // are never treated as Enter, then insert the whole block at once.
+    const START = '[200~';
+    const END = '[201~';
+    if (pasteRef.current.active || input.includes(START)) {
+      pasteRef.current.active = true;
+      pasteRef.current.buf += input;
+      const e = pasteRef.current.buf.indexOf(END);
+      if (e === -1) return; // still receiving the paste
+      const s = pasteRef.current.buf.indexOf(START);
+      const raw = pasteRef.current.buf.slice(s + START.length, e);
+      pasteRef.current = { active: false, buf: '' };
+      insertPaste(raw);
+      return;
+    }
+
     // ── Submit / complete ──
     // Some terminals/PTYs deliver Enter as input="\r" without key.return, so
     // treat a lone CR/LF as Enter too (a paste is a longer chunk, never "\r").
@@ -155,20 +194,23 @@ export function Composer({ onSubmit, busy, width = 80 }) {
 
     // ── Printable input & paste ──
     if (input && !key.ctrl && !key.meta) {
-      // Strip bracketed-paste markers, then flatten newlines/tabs from a paste.
-      let text = input.replace(/\x1b\[20[01]~/g, '');
-      const isPaste = text.length > 1 || /[\r\n\t]/.test(text);
-      text = text.replace(/[\r\n\t]+/g, ' ').replace(/[\x00-\x1f\x7f]/g, '');
+      // A multi-char chunk or one containing newlines/tabs is a non-bracketed
+      // paste (terminal without bracketed-paste support): keep its newlines.
+      if (input.length > 1 || /[\r\n\t]/.test(input)) { insertPaste(input); return; }
+      const text = input.replace(/[\x00-\x1f\x7f]/g, '');
       if (!text) return;
-      snapshot(isPaste ? 'paste' : 'type');
+      snapshot('type');
       setValue((v) => v.slice(0, cursor) + text + v.slice(cursor));
       setCursor((c) => c + text.length);
     }
   });
 
   const before = value.slice(0, cursor);
-  const at = value[cursor] ?? ' ';
-  const after = value.slice(cursor + 1);
+  const rawAt = value[cursor];
+  // When the cursor sits on a newline, show an inverse space and keep the line
+  // break in `after` so the buffer still renders across multiple lines.
+  const at = (rawAt === undefined || rawAt === '\n') ? ' ' : rawAt;
+  const after = rawAt === '\n' ? '\n' + value.slice(cursor + 1) : value.slice(cursor + 1);
   const empty = value.length === 0;
   const sugTok = menuOpen && matches[sel] ? (slashMode ? matches[sel].cmd : matches[sel].tag) : '';
   const ghost = sugTok && sugTok.startsWith(token) && cursor >= value.length ? sugTok.slice(token.length) : '';