codemaxxing 1.0.11 → 1.0.13

package/dist/index.js

@@ -4,6 +4,7 @@ import React, { useState, useEffect, useCallback } from "react";
 import { render, Box, Text, useInput, useApp, useStdout } from "ink";
 import { EventEmitter } from "events";
 import TextInput from "ink-text-input";
+import { consumePendingPasteEndMarkerChunk } from "./utils/paste.js";
 import { CodingAgent } from "./agent.js";
 import { loadConfig, saveConfig, detectLocalProvider, detectLocalProviderDetailed, parseCLIArgs, applyOverrides, listModels } from "./config.js";
 import { listSessions, getSession, loadMessages, deleteSession } from "./utils/sessions.js";
@@ -1757,6 +1758,7 @@ let bracketedBuffer = "";
 let inBracketedPaste = false;
 let burstBuffer = "";
 let burstTimer = null;
+let pendingPasteEndMarker = { active: false, buffer: "" };
 const BURST_WINDOW_MS = 50; // Long enough for slow terminals to finish delivering paste
 // Debug paste: set CODEMAXXING_DEBUG_PASTE=1 to log all stdin chunks to /tmp/codemaxxing-paste-debug.log
 const PASTE_DEBUG = process.env.CODEMAXXING_DEBUG_PASTE === "1";
@@ -1778,6 +1780,10 @@ function handlePasteContent(content) {
     const lineCount = normalized.split("\n").length;
     if (lineCount > 2) {
         // Real multiline paste → badge it
+        // Some terminals dribble the closing bracketed-paste marker (`[201~`)
+        // one character at a time *after* the paste payload. Arm a tiny
+        // swallow-state so those trailing fragments never leak into the input.
+        pendingPasteEndMarker = { active: true, buffer: "" };
         pasteEvents.emit("paste", { content: normalized, lines: lineCount });
         return;
     }
@@ -1798,8 +1804,16 @@ function looksLikeMultilinePaste(data) {
 function flushBurst() {
     if (!burstBuffer)
         return;
-    const buffered = burstBuffer;
+    let buffered = burstBuffer;
     burstBuffer = "";
+    // Strip any bracketed paste marker fragments that accumulated across
+    // individual character chunks (terminal sends [, 2, 0, 1, ~ separately)
+    buffered = buffered.replace(/\x1b?\[?20[01]~/g, "");
+    buffered = buffered.replace(/20[01]~/g, "");
+    if (!buffered || !buffered.trim()) {
+        pasteLog("BURST FLUSH stripped to empty — swallowed marker");
+        return;
+    }
     const isMultiline = looksLikeMultilinePaste(buffered);
     pasteLog(`BURST FLUSH len=${buffered.length} multiline=${isMultiline}`);
     if (isMultiline) {
@@ -1818,6 +1832,13 @@ process.stdin.emit = function (event, ...args) {
     const chunk = args[0];
     let data = typeof chunk === "string" ? chunk : Buffer.isBuffer(chunk) ? chunk.toString("utf-8") : String(chunk);
     pasteLog(`CHUNK len=${data.length} raw=${data.substring(0, 200)}`);
+    const pendingResult = consumePendingPasteEndMarkerChunk(data, pendingPasteEndMarker);
+    pendingPasteEndMarker = pendingResult.nextState;
+    data = pendingResult.remaining;
+    if (!data) {
+        pasteLog("PENDING END MARKER swallowed chunk");
+        return true;
+    }
     // Aggressively strip ALL bracketed paste escape sequences from every chunk,
     // regardless of context. Some terminals split markers across chunks or send
     // them in unexpected positions. We never want \x1b[200~ or \x1b[201~ (or

package/dist/utils/paste.d.ts

@@ -0,0 +1,9 @@
+export interface PendingPasteEndState {
+    active: boolean;
+    buffer: string;
+}
+export declare function consumePendingPasteEndMarkerChunk(chunk: string, state: PendingPasteEndState): {
+    remaining: string;
+    nextState: PendingPasteEndState;
+    swallowed: boolean;
+};

package/dist/utils/paste.js

@@ -0,0 +1,48 @@
+const END_MARKERS = ["\x1b[201~", "[201~", "201~"];
+function isPrefixOfAnyMarker(value) {
+    return END_MARKERS.some((marker) => marker.startsWith(value));
+}
+function stripLeadingFullMarkers(value) {
+    let remaining = value;
+    let stripped = false;
+    outer: while (remaining.length > 0) {
+        for (const marker of END_MARKERS) {
+            if (remaining.startsWith(marker)) {
+                remaining = remaining.slice(marker.length);
+                stripped = true;
+                continue outer;
+            }
+        }
+        break;
+    }
+    return { remaining, stripped };
+}
+export function consumePendingPasteEndMarkerChunk(chunk, state) {
+    if (!state.active) {
+        return { remaining: chunk, nextState: state, swallowed: false };
+    }
+    let combined = state.buffer + chunk;
+    let swallowed = false;
+    const stripped = stripLeadingFullMarkers(combined);
+    combined = stripped.remaining;
+    swallowed = stripped.stripped;
+    if (!combined) {
+        return {
+            remaining: "",
+            nextState: { active: false, buffer: "" },
+            swallowed,
+        };
+    }
+    if (isPrefixOfAnyMarker(combined)) {
+        return {
+            remaining: "",
+            nextState: { active: true, buffer: combined },
+            swallowed: true,
+        };
+    }
+    return {
+        remaining: combined,
+        nextState: { active: false, buffer: "" },
+        swallowed,
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codemaxxing",
-  "version": "1.0.11",
+  "version": "1.0.13",
   "description": "Open-source terminal coding agent. Connect any LLM. Max your code.",
   "main": "dist/index.js",
   "bin": {