vibe-cokit 1.6.2 → 1.6.4

package/dist/cli.js

@@ -2672,6 +2672,14 @@ import { join as join5, dirname, basename } from "path";
 import { readdir as readdir2, stat as stat2, cp as cp2, readFile, writeFile } from "fs/promises";
 var PATCH_MARKER = "/* Vietnamese IME fix */";
 var DEL_CHAR = "\x7F";
+var BINARY_BUG_PATTERN_REGEXES = [
+  /\.includes\(\s*["']\\x7[fF]["']\s*\)/g,
+  /\.includes\(\s*["']\\u007[fF]["']\s*\)/g,
+  /\.indexOf\(\s*["']\\x7[fF]["']\s*\)\s*(?:>=?\s*0|>\s*-1|!==?\s*-1)/g,
+  /\.indexOf\(\s*["']\\u007[fF]["']\s*\)\s*(?:>=?\s*0|>\s*-1|!==?\s*-1)/g
+];
+var BINARY_UNPATCHED_MARKER = "deleteToken" + "Before";
+var BINARY_UNPATCHED_MARKER_RE = new RegExp(`\\b${BINARY_UNPATCHED_MARKER}\\b`);
 function detectFileType(filePath) {
   if (filePath.includes("/claude/versions/") || filePath.includes("\\claude\\versions\\")) {
     return "binary";
@@ -2770,7 +2778,108 @@ function getBugPattern(fileType) {
   }
   return `.includes("${DEL_CHAR}")`;
 }
+function findNextBinaryPattern(content, from) {
+  let best = null;
+  for (const re of BINARY_BUG_PATTERN_REGEXES) {
+    re.lastIndex = from;
+    const m = re.exec(content);
+    if (!m || m.index < 0)
+      continue;
+    const candidate = { index: m.index, length: m[0].length };
+    if (!best || candidate.index < best.index) {
+      best = candidate;
+    }
+  }
+  return best;
+}
+function findEnclosingIfBlock(content, anchorIndex) {
+  const lookback = 260;
+  const searchStart = Math.max(0, anchorIndex - lookback);
+  const prefix = content.slice(searchStart, anchorIndex + 1);
+  let ifRelStart = -1;
+  const ifRegex = /if\s*\(/g;
+  let m;
+  while ((m = ifRegex.exec(prefix)) !== null) {
+    ifRelStart = m.index;
+  }
+  if (ifRelStart === -1)
+    return null;
+  const blockStart = searchStart + ifRelStart;
+  const firstBrace = content.indexOf("{", blockStart);
+  if (firstBrace === -1 || firstBrace < blockStart || firstBrace > anchorIndex + 220) {
+    return null;
+  }
+  let depth = 0;
+  const maxEnd = Math.min(content.length, blockStart + 1600);
+  for (let i = firstBrace;i < maxEnd; i++) {
+    const ch = content[i];
+    if (ch === "{")
+      depth++;
+    else if (ch === "}") {
+      depth--;
+      if (depth === 0)
+        return { start: blockStart, end: i + 1 };
+    }
+  }
+  return null;
+}
+function isLikelyBinaryBugBlock(block) {
+  const hasGuard = /if\s*\(\s*![\w$]+\.backspace\s*&&\s*![\w$]+\.delete\s*&&/.test(block);
+  const hasDeleteChars = /\.match\(\/\\x7[fF]\/g\)/.test(block);
+  const hasUpdateCalls = /[\w$]+\([\w$]+\.text\)\s*;\s*[\w$]+\([\w$]+\.offset\)/.test(block);
+  return hasGuard && hasDeleteChars && hasUpdateCalls;
+}
+function scanBinaryBugBlocks(content) {
+  let searchFrom = 0;
+  let patchableBlocks = 0;
+  let patternMatches = 0;
+  while (true) {
+    const match = findNextBinaryPattern(content, searchFrom);
+    if (!match)
+      break;
+    patternMatches++;
+    searchFrom = match.index + Math.max(match.length, 1);
+    const range = findEnclosingIfBlock(content, match.index);
+    if (!range)
+      continue;
+    const block = content.slice(range.start, range.end);
+    if (!isLikelyBinaryBugBlock(block))
+      continue;
+    if (!BINARY_UNPATCHED_MARKER_RE.test(block))
+      continue;
+    try {
+      extractBinaryVariables(block);
+      patchableBlocks++;
+    } catch {}
+  }
+  return { patchableBlocks, patternMatches };
+}
 function findBugBlock(content, fileType = "js") {
+  if (fileType === "binary") {
+    let searchFrom2 = 0;
+    while (true) {
+      const match = findNextBinaryPattern(content, searchFrom2);
+      if (!match) {
+        throw new Error(`Kh\xF4ng t\xECm th\u1EA5y bug pattern c\u1EE7a binary.
+` + "Claude Code c\xF3 th\u1EC3 \u0111\xE3 \u0111\u01B0\u1EE3c Anthropic fix ho\u1EB7c \u0111\u1ED5i layout.");
+      }
+      searchFrom2 = match.index + Math.max(match.length, 1);
+      const range = findEnclosingIfBlock(content, match.index);
+      if (!range)
+        continue;
+      const block = content.slice(range.start, range.end);
+      if (!isLikelyBinaryBugBlock(block))
+        continue;
+      if (!BINARY_UNPATCHED_MARKER_RE.test(block))
+        continue;
+      try {
+        extractBinaryVariables(block);
+        return { start: range.start, end: range.end, block };
+      } catch {
+        continue;
+      }
+    }
+  }
   const pattern = getBugPattern(fileType);
   let searchFrom = 0;
   while (true) {
@@ -2779,36 +2888,13 @@ function findBugBlock(content, fileType = "js") {
       throw new Error(`Kh\xF4ng t\xECm th\u1EA5y bug pattern .includes("\\x7f").
 ` + "Claude Code c\xF3 th\u1EC3 \u0111\xE3 \u0111\u01B0\u1EE3c Anthropic fix.");
     }
-    const searchStart = Math.max(0, idx - 150);
-    const blockStart = content.lastIndexOf("if(", idx);
-    if (blockStart === -1 || blockStart < searchStart) {
-      searchFrom = idx + 1;
-      continue;
-    }
-    let depth = 0;
-    let blockEnd = idx;
-    const slice = content.slice(blockStart, blockStart + 800);
-    for (let i = 0;i < slice.length; i++) {
-      if (slice[i] === "{")
-        depth++;
-      else if (slice[i] === "}") {
-        depth--;
-        if (depth === 0) {
-          blockEnd = blockStart + i + 1;
-          break;
-        }
-      }
-    }
-    if (depth !== 0) {
+    const range = findEnclosingIfBlock(content, idx);
+    if (!range) {
       searchFrom = idx + 1;
       continue;
     }
-    const block = content.slice(blockStart, blockEnd);
-    if (fileType === "binary" && !block.includes("deleteTokenBefore")) {
-      searchFrom = idx + 1;
-      continue;
-    }
-    return { start: blockStart, end: blockEnd, block };
+    const block = content.slice(range.start, range.end);
+    return { start: range.start, end: range.end, block };
   }
 }
 function extractVariables(block) {
@@ -2841,7 +2927,8 @@ function generateBinaryFix(block, vars) {
   const v = vars;
   const counterMatch = block.match(/let ([\w$]+)=\(/);
   const counter = counterMatch?.[1] ?? "XH";
-  let fix = `if(!FH.backspace&&!FH.delete&&${v.input}.includes("\\x7F")){` + `let ${counter}=(${v.input}.match(/\\x7f/g)||[]).length,` + `${v.state}=${v.curState};` + `while(${counter}--)${v.state}=${v.state}.backspace();` + `for(${counter} of ${v.input}.replace(/\\x7f/g,""))${v.state}=${v.state}.insert(${counter});` + `if(!${v.curState}.equals(${v.state})){` + `if(${v.curState}.text!==${v.state}.text)` + `${v.updateText}(${v.state}.text);` + `${v.updateOffset}(${v.state}.offset)` + `}return}`;
+  const ke = v.keyEvent ?? "FH";
+  let fix = `if(!${ke}.backspace&&!${ke}.delete&&${v.input}.includes("\\x7F")){` + `let ${counter}=(${v.input}.match(/\\x7f/g)||[]).length,` + `${v.state}=${v.curState};` + `while(${counter}--)${v.state}=${v.state}.backspace();` + `for(${counter} of ${v.input}.replace(/\\x7f/g,""))${v.state}=${v.state}.insert(${counter});` + `if(!${v.curState}.equals(${v.state})){` + `if(${v.curState}.text!==${v.state}.text)` + `${v.updateText}(${v.state}.text);` + `${v.updateOffset}(${v.state}.offset)` + `}return}`;
   const diff = block.length - fix.length;
   if (diff > 0) {
     fix = fix.slice(0, -1) + " ".repeat(diff) + "}";
@@ -2866,9 +2953,9 @@ async function patchCliJs(filePath) {
   const backupPath = join5(backupDir, `${basename(filePath)}.backup-${timestamp}`);
   await cp2(filePath, backupPath);
   try {
-    const bugPattern = getBugPattern(fileType);
     let patched = content;
     if (fileType === "binary") {
+      const beforeScan = scanBinaryBugBlocks(content);
       let patchCount = 0;
       while (patchCount < 10) {
         try {
@@ -2882,7 +2969,10 @@ async function patchCliJs(filePath) {
         }
       }
       if (patchCount === 0) {
-        throw new Error("Kh\xF4ng t\xECm th\u1EA5y bug block");
+        if (beforeScan.patternMatches > 0) {
+          throw new Error("Ph\xE1t hi\u1EC7n layout keyboard m\u1EDBi ch\u01B0a \u0111\u01B0\u1EE3c h\u1ED7 tr\u1EE3 patch");
+        }
+        throw new Error("Kh\xF4ng t\xECm th\u1EA5y bug block (Claude c\xF3 th\u1EC3 \u0111\xE3 fix upstream)");
       }
     } else {
       const { start, end, block } = findBugBlock(content, fileType);
@@ -2896,16 +2986,9 @@ async function patchCliJs(filePath) {
     await writeContent(filePath, patched, fileType);
     const verify = await readContent(filePath, fileType);
     if (fileType === "binary") {
-      let searchPos = 0;
-      while (true) {
-        const pos = verify.indexOf(bugPattern, searchPos);
-        if (pos === -1)
-          break;
-        const vicinity = verify.slice(Math.max(0, pos - 100), pos + 300);
-        if (vicinity.includes("deleteTokenBefore")) {
-          throw new Error("Verify failed: unpatched bug block still present after binary patch");
-        }
-        searchPos = pos + 1;
+      const afterScan = scanBinaryBugBlocks(verify);
+      if (afterScan.patchableBlocks > 0) {
+        throw new Error("Verify failed: unpatched bug block still present after binary patch");
       }
     } else {
       if (!verify.includes(PATCH_MARKER)) {
@@ -2926,22 +3009,30 @@ async function patchCliJs(filePath) {
   }
 }
 function extractBinaryVariables(block) {
-  const m1 = block.match(/let ([\w$]+)=\(([\w$]+)\.match\(\/\\x7f\/g\)\|\|\[\]\)\.length,([\w$]+)=([\w$]+)[;,]/);
+  const m0 = block.match(/if\s*\(\s*!([\w$]+)\.backspace\s*&&\s*!([\w$]+)\.delete\s*&&/);
+  if (!m0)
+    throw new Error("Kh\xF4ng tr\xEDch xu\u1EA5t \u0111\u01B0\u1EE3c bi\u1EBFn key event (binary)");
+  const keyEvent = m0[1];
+  const m1 = block.match(/(?:let|const)\s+([\w$]+)\s*=\s*\(([\w$]+)\.match\(\/\\x7[fF]\/g\)\|\|\[\]\)\.length\s*[,;]\s*([\w$]+)\s*=\s*([\w$]+)[;,]/);
   if (!m1)
     throw new Error("Kh\xF4ng tr\xEDch xu\u1EA5t \u0111\u01B0\u1EE3c bi\u1EBFn count/state (binary)");
   const input = m1[2];
   const state = m1[3];
   const curState = m1[4];
   const stateEsc = state.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-  const m2 = block.match(new RegExp(`([\\w$]+)\\(${stateEsc}\\.text\\);([\\w$]+)\\(${stateEsc}\\.offset\\)`));
+  const m2 = block.match(new RegExp(`([\\w$]+)\\(${stateEsc}\\.text\\)\\s*;\\s*([\\w$]+)\\(${stateEsc}\\.offset\\)`));
   if (!m2)
     throw new Error("Kh\xF4ng tr\xEDch xu\u1EA5t \u0111\u01B0\u1EE3c update functions (binary)");
+  if (!block.includes(`${state}.text`) || !block.includes(`${state}.offset`)) {
+    throw new Error("Block binary kh\xF4ng h\u1EE3p l\u1EC7: thi\u1EBFu state usage");
+  }
   return {
     input,
     state,
     curState,
     updateText: m2[1],
-    updateOffset: m2[2]
+    updateOffset: m2[2],
+    keyEvent
   };
 }
 async function checkKeyboardStatus() {
@@ -2949,26 +3040,14 @@ async function checkKeyboardStatus() {
     const cliJsPath = await findCliJs();
     const fileType = detectFileType(cliJsPath);
     const content = await readContent(cliJsPath, fileType);
-    const bugPattern = getBugPattern(fileType);
     let patched;
     let hasBug;
     if (fileType === "binary") {
-      let hasUnpatchedBlock = false;
-      let searchPos = 0;
-      while (true) {
-        const pos = content.indexOf(bugPattern, searchPos);
-        if (pos === -1)
-          break;
-        const vicinity = content.slice(Math.max(0, pos - 100), pos + 300);
-        if (vicinity.includes("deleteTokenBefore")) {
-          hasUnpatchedBlock = true;
-          break;
-        }
-        searchPos = pos + 1;
-      }
-      hasBug = hasUnpatchedBlock;
-      patched = content.includes(bugPattern) && !hasUnpatchedBlock;
+      const scan = scanBinaryBugBlocks(content);
+      hasBug = scan.patchableBlocks > 0;
+      patched = !hasBug && scan.patternMatches > 0;
     } else {
+      const bugPattern = getBugPattern(fileType);
       patched = content.includes(PATCH_MARKER);
       hasBug = content.includes(bugPattern) && !patched;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vibe-cokit",
-  "version": "1.6.2",
+  "version": "1.6.4",
   "description": "A toolkit for interacting with Claude Code",
   "module": "index.ts",
   "type": "module",