claude-code-vietnamese-fix 1.0.0

package/README.md

@@ -0,0 +1,124 @@
+# claude-code-vietnamese-fix
+
+> Fix Vietnamese input (Telex/VNI) for Claude Code CLI on Windows — one command, zero config.
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+[![Platform](https://img.shields.io/badge/platform-Windows-blue)]()
+[![Claude Code](https://img.shields.io/badge/Claude_Code-v2.x-blueviolet)]()
+
+## The Problem
+
+Vietnamese users **cannot type** in Claude Code CLI. Characters get duplicated or garbled.
+
+**Expected:** `tôi` → **Actual:** `toôooi`
+
+Unikey sends backspace (`\x08`) + replacement chars embedded in the input string. Claude Code's input handler doesn't process these embedded BS chars — it inserts the entire string as-is.
+
+## Quick Start
+
+### Option 1: npx (no install needed)
+
+```bash
+npx claude-code-vietnamese-fix
+```
+
+### Option 2: Install globally
+
+```bash
+npm install -g claude-code-vietnamese-fix
+claude-code-vietnamese-fix
+```
+
+### Option 3: Clone and run
+
+```bash
+git clone https://github.com/tvtdev94/claude-code-vietnamese-fix.git
+cd claude-code-vietnamese-fix
+node patch-vietnamese-ime.js
+```
+
+Then **restart Claude Code**.
+
+## How it works
+
+The patch wraps Claude Code's `onInput` handler. When embedded BS chars (`\x08`) are detected, it processes each character sequentially against the cursor state:
+- `\x08` (BS) → `cursor.backspace()` — deletes the previous char
+- Any other char → `cursor.insert(char)` — inserts normally
+
+The final cursor state is applied atomically.
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `npx claude-code-vietnamese-fix` | Patch cli.js (auto-finds, auto-backups) |
+| `npx claude-code-vietnamese-fix --status` | Check current patch status |
+| `npx claude-code-vietnamese-fix --restore` | Restore original cli.js from backup |
+| `npx claude-code-vietnamese-fix --silent` | Patch without output if already patched |
+
+## Auto-patch After Updates
+
+Claude Code updates will overwrite the patch. Add a SessionStart hook to auto-patch:
+
+Add to `~/.claude/settings.json`:
+
+```json
+{
+  "hooks": {
+    "SessionStart": [
+      {
+        "matcher": "startup|resume|clear|compact",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "npx claude-code-vietnamese-fix --silent"
+          }
+        ]
+      }
+    ]
+  }
+}
+```
+
+The script is **idempotent** — safe to run on every session start.
+
+## Restore
+
+If anything goes wrong:
+
+```bash
+npx claude-code-vietnamese-fix --restore
+```
+
+Backup location: `%APPDATA%\npm\node_modules\@anthropic-ai\claude-code\cli.js.bak`
+
+## Compatibility
+
+| Item | Status |
+|------|--------|
+| Windows 10/11 | ✅ |
+| Unikey (Telex) | ✅ Tested |
+| Unikey (VNI, VIQR) | ⚠️ Untested (should work) |
+| OpenKey / EVKey | ⚠️ Untested (should work) |
+| npm global install | ✅ |
+| NVM for Windows | ✅ |
+| Claude Code v2.x | ✅ |
+
+## Debug
+
+Capture raw input bytes to diagnose IME behavior:
+
+```bash
+node capture-input.js
+# Type Vietnamese text, press Ctrl+C to stop
+```
+
+## Related
+
+- [Issue #3961](https://github.com/anthropics/claude-code/issues/3961) — Unicode Input Handling Fails for Vietnamese Characters
+- [Issue #7989](https://github.com/anthropics/claude-code/issues/7989) — Error typing Vietnamese Telex
+- [Issue #10429](https://github.com/anthropics/claude-code/issues/10429) — Vietnamese Input Not Working
+
+## License
+
+[MIT](LICENSE)

package/capture-input.js

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+/**
+ * Capture raw stdin bytes to debug Vietnamese IME input.
+ * Run: node capture-input.js
+ * Type Vietnamese text, press Ctrl+C to stop.
+ * Shows hex dump of every byte received.
+ */
+process.stdin.setRawMode(true);
+process.stdin.resume();
+process.stdin.setEncoding(null);
+
+console.log("Type Vietnamese text (Ctrl+C to quit):\n");
+
+process.stdin.on("data", (buf) => {
+  const hex = [...buf].map(b => b.toString(16).padStart(2, "0")).join(" ");
+  const chars = [...buf].map(b => b >= 32 && b < 127 ? String.fromCharCode(b) : b === 0x7f ? "<DEL>" : b === 0x08 ? "<BS>" : `\\x${b.toString(16).padStart(2, "0")}`).join("");
+  const utf8 = buf.toString("utf8");
+  console.log(`HEX: ${hex}`);
+  console.log(`RAW: ${chars}`);
+  console.log(`UTF: ${utf8}`);
+  console.log("---");
+});
+
+process.on("SIGINT", () => { console.log("\nDone."); process.exit(); });

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "claude-code-vietnamese-fix",
+  "version": "1.0.0",
+  "description": "Fix Vietnamese IME input (Unikey/Telex) for Claude Code CLI on Windows",
+  "bin": {
+    "claude-code-vietnamese-fix": "patch-vietnamese-ime.js"
+  },
+  "scripts": {
+    "patch": "node patch-vietnamese-ime.js",
+    "patch:silent": "node patch-vietnamese-ime.js --silent",
+    "status": "node patch-vietnamese-ime.js --status",
+    "restore": "node patch-vietnamese-ime.js --restore"
+  },
+  "keywords": ["claude-code", "vietnamese", "ime", "unikey", "telex", "windows", "patch"],
+  "author": "tvtdev94",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/tvtdev94/claude-code-vietnamese-fix"
+  },
+  "engines": {
+    "node": ">=16"
+  }
+}

package/patch-vietnamese-ime.js

@@ -0,0 +1,219 @@
+#!/usr/bin/env node
+
+/**
+ * Patch Claude Code CLI to fix Vietnamese IME input (Unikey/Telex) on Windows.
+ *
+ * Root cause: Unikey sends backspace chars (\x08) embedded in the input string
+ * along with replacement chars. Claude Code's input handler doesn't process
+ * these embedded BS chars — it inserts the entire string as-is, causing
+ * duplicate/garbled characters.
+ *
+ * Fix: Wrap the input handler to detect embedded \x08 (BS) in the input
+ * string. When found, process each char sequentially: regular chars get
+ * inserted, \x08 triggers a cursor.backspace(). The result is applied
+ * atomically to avoid stale-state issues.
+ *
+ * Usage:
+ *   node patch-vietnamese-ime.js            # patch (auto-find cli.js)
+ *   node patch-vietnamese-ime.js --silent   # patch, no output if already patched
+ *   node patch-vietnamese-ime.js --restore  # restore from backup
+ *   node patch-vietnamese-ime.js --status   # check patch status
+ *   node patch-vietnamese-ime.js -f <path>  # specify cli.js path manually
+ */
+
+const fs = require("fs");
+const path = require("path");
+const { execSync } = require("child_process");
+
+const PATCH_MARKER = "/* _vietnamese_ime_fix_v4_ */";
+
+// --- CLI argument parsing ---
+
+function parseArgs() {
+  const args = process.argv.slice(2);
+  const opts = { silent: false, restore: false, status: false, file: null };
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--silent") opts.silent = true;
+    else if (args[i] === "--restore") opts.restore = true;
+    else if (args[i] === "--status") opts.status = true;
+    else if (args[i] === "-f" || args[i] === "--file") opts.file = args[++i];
+  }
+  return opts;
+}
+
+// --- Locate cli.js on Windows ---
+
+function findCliJs() {
+  const run = (cmd) => {
+    try {
+      return execSync(cmd, { stdio: ["ignore", "pipe", "ignore"] })
+        .toString().split(/\r?\n/)[0].trim();
+    } catch { return ""; }
+  };
+  const exists = (p) => p && fs.existsSync(p);
+
+  // npm global
+  try {
+    const npmRoot = run("npm root -g");
+    const p = path.join(npmRoot, "@anthropic-ai", "claude-code", "cli.js");
+    if (exists(p)) return p;
+  } catch {}
+
+  // Common Windows paths
+  const paths = [
+    path.join(process.env.APPDATA || "", "npm", "node_modules", "@anthropic-ai", "claude-code", "cli.js"),
+    path.join(process.env.LOCALAPPDATA || "", "npm", "node_modules", "@anthropic-ai", "claude-code", "cli.js"),
+  ];
+  if (process.env.NVM_HOME) {
+    try {
+      for (const dir of fs.readdirSync(process.env.NVM_HOME)) {
+        paths.push(path.join(process.env.NVM_HOME, dir, "node_modules", "@anthropic-ai", "claude-code", "cli.js"));
+      }
+    } catch {}
+  }
+  for (const p of paths) { if (exists(p)) return p; }
+  return null;
+}
+
+// --- Patch logic ---
+
+function patchContent(content) {
+  if (content.includes(PATCH_MARKER)) {
+    return { success: true, alreadyPatched: true };
+  }
+
+  let patched = content;
+
+  // Find the input handler function:
+  //   function n(t,r){let l=G?G(t,r):t;if(l===""&&t!=="")return;...}
+  // This is the onInput handler for Claude Code's text input component.
+  const outerRe = /function\s+([\w$]+)\(([\w$]+),([\w$]+)\)\{let\s+([\w$]+)=([\w$]+)\?\5\(\2,\3\):\2;if\(\4===""&&\2!==""\)return;/;
+  const outerMatch = patched.match(outerRe);
+
+  if (!outerMatch) {
+    return { success: false, message: "Patch failed: input handler function not found" };
+  }
+
+  const [fullMatch, fn, p1, p2, p3, p4] = outerMatch;
+
+  // The wrapper intercepts input strings containing \x08 (BS) chars.
+  // When detected, it processes each char against the cursor state `h`:
+  //   - \x08: cursor.backspace()
+  //   - other: cursor.insert(char)
+  // Then applies the final state atomically.
+  //
+  // For strings without \x08, passes through to original handler unchanged.
+  //
+  // Variables from the enclosing closure (captured by the original function):
+  //   h = cursor state, q = setText, L = setOffset
+  //   These are referenced via the original function's scope.
+  const wrapper =
+    `${PATCH_MARKER}` +
+    `function ${fn}(${p1},${p2}){` +
+      // Check for embedded BS chars (0x08) — Vietnamese IME signature
+      `if(!${p2}.backspace&&!${p2}.delete&&${p1}.includes("\\b")){` +
+        // Process char-by-char against cursor state h (from enclosing closure)
+        `var _c=h;` +
+        `for(var _i=0;_i<${p1}.length;_i++){` +
+          `var _ch=${p1}[_i];` +
+          `if(_ch==="\\b"){` +
+            `_c=_c.backspace()` +
+          `}else{` +
+            `_c=_c.insert(_ch)` +
+          `}` +
+        `}` +
+        // Apply final state atomically
+        `if(!h.equals(_c)){` +
+          `if(h.text!==_c.text)q(_c.text);` +
+          `L(_c.offset)` +
+        `}` +
+        `return` +
+      `}` +
+      // No embedded BS: pass through to original handler
+      `return _imeR(${p1},${p2})}` +
+    // Original function renamed to _imeR
+    `function _imeR(${p1},${p2}){` +
+      `let ${p3}=${p4}?${p4}(${p1},${p2}):${p1};` +
+      `if(${p3}===""&&${p1}!=="")return;`;
+
+  patched = patched.replace(fullMatch, wrapper);
+
+  if (patched.includes(fullMatch) && !patched.includes("_imeR")) {
+    return { success: false, message: "Patch: replacement failed" };
+  }
+
+  return { success: true, alreadyPatched: false, content: patched };
+}
+
+// --- Backup & restore ---
+
+function backupPath(cliPath) { return cliPath + ".bak"; }
+
+function createBackup(cliPath) {
+  const bak = backupPath(cliPath);
+  fs.copyFileSync(cliPath, bak);
+  return bak;
+}
+
+function restoreBackup(cliPath) {
+  const bak = backupPath(cliPath);
+  if (!fs.existsSync(bak)) return { success: false, message: "No backup found at " + bak };
+  fs.copyFileSync(bak, cliPath);
+  return { success: true };
+}
+
+// --- Main ---
+
+function main() {
+  const opts = parseArgs();
+  const cliPath = opts.file || findCliJs();
+
+  if (!cliPath || !fs.existsSync(cliPath)) {
+    console.error("Error: Could not find Claude Code cli.js");
+    if (cliPath) console.error("Tried: " + cliPath);
+    process.exit(1);
+  }
+
+  if (opts.status) {
+    const content = fs.readFileSync(cliPath, "latin1");
+    const patched = content.includes(PATCH_MARKER);
+    console.log(`Target: ${cliPath}`);
+    console.log(`Status: ${patched ? "PATCHED" : "NOT PATCHED"}`);
+    console.log(`Backup: ${fs.existsSync(backupPath(cliPath)) ? "EXISTS" : "NONE"}`);
+    process.exit(0);
+  }
+
+  if (opts.restore) {
+    const result = restoreBackup(cliPath);
+    if (!result.success) { console.error(result.message); process.exit(1); }
+    console.log("Restored cli.js from backup");
+    process.exit(0);
+  }
+
+  // Restore from backup first if exists (ensure clean base for patching)
+  if (fs.existsSync(backupPath(cliPath))) {
+    fs.copyFileSync(backupPath(cliPath), cliPath);
+  }
+
+  const content = fs.readFileSync(cliPath, "latin1");
+  const result = patchContent(content);
+
+  if (result.alreadyPatched) {
+    if (!opts.silent) console.log("Already patched — skipping");
+    process.exit(0);
+  }
+
+  if (!result.success) {
+    console.error(result.message);
+    process.exit(1);
+  }
+
+  // Backup original before writing patch
+  createBackup(cliPath);
+  if (!opts.silent) console.log("Backup: " + backupPath(cliPath));
+
+  fs.writeFileSync(cliPath, result.content, "latin1");
+  console.log("Patched: " + cliPath);
+}
+
+main();