sigrank 0.17.3 → 0.17.5

package/README.md

@@ -147,7 +147,7 @@ smithery tool call sigrank rank_paste '{"text": "1000000 500000 50000 800000"}'
 ## Commands
 
 ```
-⊙ SigRank CLI  v0.17.3
+⊙ SigRank CLI  v0.17.5
 
 Default (no args)
   sigrank              unified dashboard: cascade + token pillars + board

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sigrank",
-  "version": "0.17.3",
+  "version": "0.17.5",
   "author": "SunrisesIllNeverSee (https://github.com/SunrisesIllNeverSee)",
   "description": "SigRank MCP server — the yield cascade + live leaderboard as MCP tools any agent can call",
   "mcpName": "io.github.SunrisesIllNeverSee/sigrank-mcp",

package/tui.mjs

@@ -2136,8 +2136,17 @@ export async function runTui({
   process.stdin.resume();
   process.stdin.setEncoding("utf8");
 
+  // Esc-sequence buffer: some terminals (SSH, tmux, certain emulators) split an
+  // arrow key (\x1b[C) into two data events: \x1b then [C. Without buffering, the
+  // lone \x1b triggers the Esc handler (clearing the code buffer / leaving the tab)
+  // before the [C arrives. We hold \x1b for 25ms; if more bytes follow, we
+  // reassemble and deliver the full sequence. If nothing follows, it's a real Esc.
+  let escBuf = null;
+  let escTimer = null;
+  const ESC_HOLD_MS = 25;
+
   await new Promise((resolve) => {
-    process.stdin.on("data", async (key) => {
+    const handleKey = async (key) => {
       const k = key.toLowerCase();
 
       if (k === "q" || k === "\x03") {
@@ -2183,9 +2192,11 @@ export async function runTui({
                   "sign-in is temporarily unavailable — try again shortly.",
               };
               connectMsg = `${red("✗")} ${reasons[out.reason] || `sign-in failed (${out.reason || "unknown"}).`}`;
+              codeBuf = ""; // auto-clear on failure — the code is consumed/invalid
             }
           } catch (e) {
             connectMsg = `${red("✗")} ${e.message}`;
+            codeBuf = ""; // auto-clear on error too
           }
           await redraw();
           return;
@@ -2216,13 +2227,13 @@ export async function runTui({
           await redraw();
           return;
         } // backspace
-        // [X] sign out / reset — when the code field is empty (so an 'x' typed mid-code
-        // still feeds the buffer). Drops the local credential so a server-revoked OR
-        // server-enrolled-but-locally-unbound device stops holding a stale device_id,
-        // and the next enroll provisions a fresh device_id (escapes the Frankenstein-
-        // identity / 409-re-enroll deadlock). Works whether or not isSignedIn() —
-        // otherwise a device enrolled server-side but unbound locally is un-escapable
-        // (can't sign in: device_already_enrolled; can't sign out: X gated off).
+        // [X] sign out / reset — only when the code field is empty (so 'x'/'X' typed
+        // mid-code still feeds the buffer — codes can contain X). The auto-clear on
+        // sign-in failure (above) ensures the buffer is empty after a failed attempt,
+        // so X works immediately when the user wants to reset. Drops the local
+        // credential so a server-revoked OR server-enrolled-but-locally-unbound device
+        // stops holding a stale device_id, and the next enroll provisions a fresh
+        // device_id (escapes the Frankenstein-identity / 409-re-enroll deadlock).
         if (k === "x" && !codeBuf) {
           const wasSignedIn = isSignedIn(loadIdentity());
           clearIdentity();
@@ -2589,6 +2600,45 @@ export async function runTui({
 
       if (switched) submitMsg = ""; // submit result is tied to the tab it was sent from
       if (switched || k === "w") await redraw();
+    };
+
+    // Buffered stdin listener: reassembles split Esc sequences before dispatch.
+    process.stdin.on("data", (chunk) => {
+      // If we have a pending \x1b held from a previous chunk, combine it with
+      // this chunk to reassemble the full escape sequence (\x1b + [C = \x1b[C).
+      if (escBuf) {
+        clearTimeout(escTimer);
+        const combined = escBuf + chunk;
+        escBuf = null;
+        escTimer = null;
+        // If the combined result is \x1b followed by more \x1b (rare), just
+        // deliver the first as Esc and re-buffer the second. Otherwise deliver
+        // the combined sequence.
+        if (combined.length > 1) {
+          handleKey(combined);
+          return;
+        }
+        // combined is still just \x1b (chunk was empty?) → fall through to hold
+      }
+
+      // Fast path: chunk doesn't start with \x1b → deliver immediately.
+      if (chunk[0] !== "\x1b") {
+        handleKey(chunk);
+        return;
+      }
+      // Chunk starts with \x1b and is longer than 1 byte → complete escape
+      // sequence → deliver immediately.
+      if (chunk.length > 1) {
+        handleKey(chunk);
+        return;
+      }
+      // Chunk is exactly \x1b → hold for ESC_HOLD_MS to see if more bytes follow.
+      escBuf = chunk;
+      escTimer = setTimeout(() => {
+        handleKey(escBuf);
+        escBuf = null;
+        escTimer = null;
+      }, ESC_HOLD_MS);
     });
   });