vibe-cokit 1.6.0 → 1.6.2

package/dist/cli.js

@@ -938,8 +938,8 @@ var stubFalse_default = stubFalse;
 var freeExports = typeof exports_isBuffer == "object" && exports_isBuffer && !exports_isBuffer.nodeType && exports_isBuffer;
 var freeModule = freeExports && typeof module_isBuffer == "object" && module_isBuffer && !module_isBuffer.nodeType && module_isBuffer;
 var moduleExports = freeModule && freeModule.exports === freeExports;
-var Buffer = moduleExports ? _root_default.Buffer : undefined;
-var nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined;
+var Buffer2 = moduleExports ? _root_default.Buffer : undefined;
+var nativeIsBuffer = Buffer2 ? Buffer2.isBuffer : undefined;
 var isBuffer = nativeIsBuffer || stubFalse_default;
 var isBuffer_default = isBuffer;
 
@@ -2669,12 +2669,35 @@ import { join as join6 } from "path";
 // src/utils/keyboard.ts
 import { homedir as homedir2, platform } from "os";
 import { join as join5, dirname, basename } from "path";
-import { readdir as readdir2, stat as stat2, cp as cp2 } from "fs/promises";
+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";
+function detectFileType(filePath) {
+  if (filePath.includes("/claude/versions/") || filePath.includes("\\claude\\versions\\")) {
+    return "binary";
+  }
+  return "js";
+}
 async function findCliJs() {
   const home = homedir2();
   const isWin = platform() === "win32";
+  const nativePath = join5(home, ".local", "share", "claude", "versions");
+  try {
+    const s = await stat2(nativePath);
+    if (s.isDirectory()) {
+      const entries = await readdir2(nativePath);
+      const versions = entries.filter((e) => /^\d+\.\d+\.\d+$/.test(e));
+      versions.sort((a, b) => b.localeCompare(a, undefined, { numeric: true }));
+      for (const ver of versions) {
+        const binPath = join5(nativePath, ver);
+        try {
+          const bs = await stat2(binPath);
+          if (bs.isFile())
+            return binPath;
+        } catch {}
+      }
+    }
+  } catch {}
   const searchDirs = isWin ? [
     join5(process.env.LOCALAPPDATA ?? "", "npm-cache", "_npx"),
     join5(process.env.APPDATA ?? "", "npm", "node_modules")
@@ -2696,7 +2719,7 @@ async function findCliJs() {
     if (found)
       return found;
   }
-  throw new Error(`Kh\xF4ng t\xECm th\u1EA5y Claude Code npm.
+  throw new Error(`Kh\xF4ng t\xECm th\u1EA5y Claude Code.
 ` + "C\xE0i \u0111\u1EB7t tr\u01B0\u1EDBc: npm install -g @anthropic-ai/claude-code");
 }
 async function findCliJsRecursive(dir, depth, maxDepth) {
@@ -2726,40 +2749,67 @@ async function findCliJsRecursive(dir, depth, maxDepth) {
   } catch {}
   return null;
 }
-function findBugBlock(content) {
-  const pattern = `.includes("${DEL_CHAR}")`;
-  const idx = content.indexOf(pattern);
-  if (idx === -1) {
-    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.");
+async function readContent(filePath, fileType) {
+  if (fileType === "binary") {
+    const buf = await readFile(filePath);
+    return buf.toString("latin1");
   }
-  const searchStart = Math.max(0, idx - 150);
-  const blockStart = content.lastIndexOf("if(", idx);
-  if (blockStart === -1 || blockStart < searchStart) {
-    throw new Error("Kh\xF4ng t\xECm th\u1EA5y block if ch\u1EE9a pattern");
-  }
-  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;
+  return Bun.file(filePath).text();
+}
+async function writeContent(filePath, content, fileType) {
+  if (fileType === "binary") {
+    const bytes = Buffer.from(content, "latin1");
+    await writeFile(filePath, bytes);
+  } else {
+    await Bun.write(filePath, content);
+  }
+}
+function getBugPattern(fileType) {
+  if (fileType === "binary") {
+    return '.includes("\\x7F")';
+  }
+  return `.includes("${DEL_CHAR}")`;
+}
+function findBugBlock(content, fileType = "js") {
+  const pattern = getBugPattern(fileType);
+  let searchFrom = 0;
+  while (true) {
+    const idx = content.indexOf(pattern, searchFrom);
+    if (idx === -1) {
+      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) {
+      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 };
   }
-  if (depth !== 0) {
-    throw new Error("Kh\xF4ng t\xECm th\u1EA5y closing brace c\u1EE7a block if");
-  }
-  return {
-    start: blockStart,
-    end: blockEnd,
-    block: content.slice(blockStart, blockEnd)
-  };
 }
 function extractVariables(block) {
   const normalized = block.replaceAll(DEL_CHAR, "\\x7f");
@@ -2787,28 +2837,80 @@ function generateFix(vars) {
   const v = vars;
   return `${PATCH_MARKER}` + `if(${v.input}.includes("\\x7f")){` + `let _n=(${v.input}.match(/\\x7f/g)||[]).length,` + `_vn=${v.input}.replace(/\\x7f/g,""),` + `${v.state}=${v.curState};` + `for(let _i=0;_i<_n;_i++)${v.state}=${v.state}.backspace();` + `for(const _c of _vn)${v.state}=${v.state}.insert(_c);` + `if(!${v.curState}.equals(${v.state})){` + `if(${v.curState}.text!==${v.state}.text)` + `${v.updateText}(${v.state}.text);` + `${v.updateOffset}(${v.state}.offset)` + `}return;}`;
 }
+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 diff = block.length - fix.length;
+  if (diff > 0) {
+    fix = fix.slice(0, -1) + " ".repeat(diff) + "}";
+  } else if (diff < 0) {
+    throw new Error(`Fix code qu\xE1 d\xE0i (${-diff} bytes). Kh\xF4ng th\u1EC3 patch binary.`);
+  }
+  return fix;
+}
 async function patchCliJs(filePath) {
-  const file = Bun.file(filePath);
-  if (!await file.exists()) {
+  const fileType = detectFileType(filePath);
+  try {
+    await stat2(filePath);
+  } catch {
     return { success: false, message: `File kh\xF4ng t\u1ED3n t\u1EA1i: ${filePath}` };
   }
-  const content = await file.text();
+  const content = await readContent(filePath, fileType);
   if (content.includes(PATCH_MARKER)) {
     return { success: false, message: "\u0110\xE3 patch tr\u01B0\u1EDBc \u0111\xF3" };
   }
   const timestamp = new Date().toISOString().replace(/[:.]/g, "-").slice(0, 19);
-  const backupPath = `${filePath}.backup-${timestamp}`;
+  const backupDir = fileType === "binary" ? "/tmp" : dirname(filePath);
+  const backupPath = join5(backupDir, `${basename(filePath)}.backup-${timestamp}`);
   await cp2(filePath, backupPath);
   try {
-    const { start, end } = findBugBlock(content);
-    const block = content.slice(start, end);
-    const vars = extractVariables(block);
-    const fix = generateFix(vars);
-    const patched = content.slice(0, start) + fix + content.slice(end);
-    await Bun.write(filePath, patched);
-    const verify = await Bun.file(filePath).text();
-    if (!verify.includes(PATCH_MARKER)) {
-      throw new Error("Verify failed: patch marker not found after write");
+    const bugPattern = getBugPattern(fileType);
+    let patched = content;
+    if (fileType === "binary") {
+      let patchCount = 0;
+      while (patchCount < 10) {
+        try {
+          const { start, end, block } = findBugBlock(patched, fileType);
+          const vars = extractBinaryVariables(block);
+          const fix = generateBinaryFix(block, vars);
+          patched = patched.slice(0, start) + fix + patched.slice(end);
+          patchCount++;
+        } catch {
+          break;
+        }
+      }
+      if (patchCount === 0) {
+        throw new Error("Kh\xF4ng t\xECm th\u1EA5y bug block");
+      }
+    } else {
+      const { start, end, block } = findBugBlock(content, fileType);
+      const vars = extractVariables(block);
+      const fix = generateFix(vars);
+      patched = content.slice(0, start) + fix + content.slice(end);
+    }
+    if (fileType === "binary" && patched.length !== content.length) {
+      throw new Error(`Binary patch size mismatch: ${patched.length} vs ${content.length}`);
+    }
+    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;
+      }
+    } else {
+      if (!verify.includes(PATCH_MARKER)) {
+        throw new Error("Verify failed: patch marker not found after write");
+      }
     }
     return { success: true, message: "Patch th\xE0nh c\xF4ng", backupPath };
   } catch (err) {
@@ -2823,16 +2925,56 @@ async function patchCliJs(filePath) {
     };
   }
 }
+function extractBinaryVariables(block) {
+  const m1 = block.match(/let ([\w$]+)=\(([\w$]+)\.match\(\/\\x7f\/g\)\|\|\[\]\)\.length,([\w$]+)=([\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\\)`));
+  if (!m2)
+    throw new Error("Kh\xF4ng tr\xEDch xu\u1EA5t \u0111\u01B0\u1EE3c update functions (binary)");
+  return {
+    input,
+    state,
+    curState,
+    updateText: m2[1],
+    updateOffset: m2[2]
+  };
+}
 async function checkKeyboardStatus() {
   try {
     const cliJsPath = await findCliJs();
-    const file = Bun.file(cliJsPath);
-    const content = await file.text();
-    const patched = content.includes(PATCH_MARKER);
-    const hasBug = content.includes(`.includes("${DEL_CHAR}")`);
-    return { cliJsFound: true, cliJsPath, isPatched: patched, hasBug: !patched && hasBug };
+    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;
+    } else {
+      patched = content.includes(PATCH_MARKER);
+      hasBug = content.includes(bugPattern) && !patched;
+    }
+    return { cliJsFound: true, cliJsPath, isPatched: patched, hasBug, isBinary: fileType === "binary" };
   } catch {
-    return { cliJsFound: false, cliJsPath: null, isPatched: false, hasBug: false };
+    return { cliJsFound: false, cliJsPath: null, isPatched: false, hasBug: false, isBinary: false };
   }
 }
 

package/package.json

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