cline-kit 0.1.0

package/src/detect.js

@@ -0,0 +1,118 @@
+"use strict";
+// Locate cline-app.exe without hardcoding anyone's install path.
+const { execFileSync } = require("child_process");
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+
+const EXE = process.platform === "win32" ? "cline-app.exe" : "cline-app";
+
+function fromRunningProcess() {
+  if (process.platform !== "win32") return null;
+  try {
+    const out = execFileSync("powershell.exe", [
+      "-NoProfile", "-Command",
+      "(Get-Process -Name cline-app -ErrorAction SilentlyContinue | Select-Object -First 1).Path"
+    ], { encoding: "utf8", timeout: 15000 });
+    const p = out.trim().replace(/^"|"$/g, "");
+    return p && fs.existsSync(p) ? p : null;
+  } catch (e) { return null; }
+}
+
+function fromRegistry() {
+  if (process.platform !== "win32") return null;
+  const roots = [
+    "HKCU:\\Software\\Microsoft\\Windows\\CurrentVersion\\Uninstall",
+    "HKLM:\\Software\\Microsoft\\Windows\\CurrentVersion\\Uninstall",
+    "HKLM:\\Software\\WOW6432Node\\Microsoft\\Windows\\CurrentVersion\\Uninstall"
+  ];
+  // PowerShell treats backslash literally, so paths must be single-quoted, not JSON-encoded.
+  const q = (s) => "'" + String(s).replace(/'/g, "''") + "'";
+  const script = `$roots = @(${roots.map(q).join(",")})
+foreach ($r in $roots) {
+  Get-ChildItem $r -ErrorAction SilentlyContinue | ForEach-Object {
+    $p = Get-ItemProperty $_.PSPath -ErrorAction SilentlyContinue
+    if ($p.DisplayName -match 'cline') {
+      foreach ($k in @('InstallLocation','DisplayIcon','UninstallString')) {
+        $v = $p.$k
+        if ($v) { Write-Output ("$k=$v") }
+      }
+    }
+  }
+}`;
+  try {
+    const out = execFileSync("powershell.exe", ["-NoProfile", "-Command", script], { encoding: "utf8", timeout: 20000 });
+    let installLocation = null;
+    for (const line of out.split(/\r?\n/)) {
+      const i = line.indexOf("=");
+      if (i < 0) continue;
+      const k = line.slice(0, i), v = line.slice(i + 1).trim().replace(/^"|"$/g, "");
+      if (k === "InstallLocation" && v) installLocation = v;
+      if (k === "DisplayIcon" && /cline-app\.exe/i.test(v)) return v.split(",")[0];
+      if (k === "UninstallString") {
+        const m = v.match(/^(?:"([^"]+)"|[^\s]+)|(.+)/);
+        const guess = (v.match(/[A-Za-z]:[^"]*?cline-app\.exe/i) || [])[0];
+        if (guess) return guess;
+      }
+    }
+    if (installLocation) {
+      const p = path.join(installLocation, EXE);
+      if (fs.existsSync(p)) return p;
+    }
+  } catch (e) { /* registry unreadable */ }
+  return null;
+}
+
+function fromCommonPaths() {
+  const candidates = [];
+  const env = process.env;
+  if (process.platform === "win32") {
+    const roots = [
+      env.LOCALAPPDATA && path.join(env.LOCALAPPDATA, "Programs", "Cline"),
+      env.LOCALAPPDATA && path.join(env.LOCALAPPDATA, "Programs", "cline-app"),
+      env.PROGRAMFILES && path.join(env.PROGRAMFILES, "Cline"),
+      env["PROGRAMFILES(X86)"] && path.join(env["PROGRAMFILES(X86)"], "Cline"),
+      env.ProgramFiles && path.join(env.ProgramFiles, "cline")
+    ];
+    candidates.push(...roots.filter(Boolean).map((d) => path.join(d, EXE)));
+    // a few fixed-drive variants people commonly use
+    for (const drive of ["C:", "D:", "E:"]) {
+      candidates.push(path.join(drive + "\\", "Programs", "Cline", EXE));
+      candidates.push(path.join(drive + "\\", "Program Files", "Cline", EXE));
+    }
+  } else {
+    candidates.push("/Applications/Cline.app/Contents/MacOS/" + EXE);
+    candidates.push(path.join(os.homedir(), ".cline", "bin", EXE));
+    candidates.push(path.join("/usr/local/bin", EXE));
+  }
+  for (const c of candidates) { try { if (fs.existsSync(c)) return c; } catch (e) { } }
+  return null;
+}
+
+function fromPath() {
+  try {
+    const cmd = process.platform === "win32" ? "where.exe" : "which";
+    const out = execFileSync(cmd, [EXE], { encoding: "utf8", timeout: 8000 });
+    const p = out.split(/\r?\n/)[0].trim();
+    return p && fs.existsSync(p) ? p : null;
+  } catch (e) { return null; }
+}
+
+// ordered resolution; each source is labelled so `status` can explain the choice
+function detect(cfg) {
+  const sources = [
+    ["config", () => (cfg && cfg.clinePath && fs.existsSync(cfg.clinePath) ? cfg.clinePath : null)],
+    ["running-process", fromRunningProcess],
+    ["registry", fromRegistry],
+    ["common-paths", fromCommonPaths],
+    ["path-env", fromPath]
+  ];
+  for (const [name, fn] of sources) {
+    let p = null;
+    try { p = fn(); } catch (e) { p = null; }
+    if (p) return { path: p, source: name };
+  }
+  return { path: null, source: null };
+}
+
+module.exports = { detect, EXE };

package/src/dict.js

@@ -0,0 +1,171 @@
+"use strict";
+// Dictionary loading + optional GitHub-hosted updates.
+// Precedence (lowest -> highest): bundled JSON, cached remote JSON, user local override JSON.
+const fs = require("fs");
+const path = require("path");
+const cfg = require("./config");
+
+function readJson(p) {
+  try { return JSON.parse(fs.readFileSync(p, "utf8")); } catch (e) { return null; }
+}
+
+// Heuristic guard for catastrophic backtracking: a quantified group whose body already ends in a
+// quantifier, or alternates between quantified atoms - (a+)+ / (a+|b)+ / (a{2,})+.
+function nestedQuantifier(pattern) {
+  const s = String(pattern).replace(/\\./g, "  "); // drop escapes: \( and \) must not confuse the scan
+  for (let i = 0; i < s.length - 1; i++) {
+    if (s[i] !== ")") continue;
+    const q = s[i + 1];
+    if (q !== "*" && q !== "+" && q !== "{") continue;
+    let depth = 0, j = i;
+    for (; j >= 0; j--) {
+      if (s[j] === ")") depth++;
+      else if (s[j] === "(") { depth--; if (depth === 0) break; }
+    }
+    if (j < 0) continue;
+    const body = s.slice(j + 1, i).replace(/\s+$/, "");
+    if (/[*+}]$/.test(body) || /\|[^|]*[*+]/.test(body)) return true;
+  }
+  return false;
+}
+
+function bundledPath(name) {
+  return path.join(__dirname, "..", "dictionaries", name + ".json");
+}
+
+function validate(d) {
+  if (!d || typeof d !== "object") return false;
+  if (typeof d.version !== "number") return false;
+  if (!d.entries || typeof d.entries !== "object" || Array.isArray(d.entries)) return false;
+  if (!Array.isArray(d.rules) || !Array.isArray(d.prefixes)) return false;
+
+  // Remote dictionaries are data, but they do feed new RegExp(). Keep them anchored and small
+  // so a hostile or broken file cannot inject arbitrary behaviour or a pathological regex.
+  const keys = Object.keys(d.entries);
+  if (keys.length > 20000) return false;
+  for (const k of keys) {
+    if (typeof k !== "string" || k.length > 400) return false;
+    if (typeof d.entries[k] !== "string" || d.entries[k].length > 400) return false;
+  }
+  for (const r of d.rules) {
+    if (!r || typeof r.pattern !== "string" || typeof r.out !== "string") return false;
+    if (r.pattern.length > 200 || r.out.length > 200) return false;
+    if (r.pattern[0] !== "^" || r.pattern[r.pattern.length - 1] !== "$") return false;
+    // Patterns reach new RegExp() in the webview, so a nested quantifier such as (a+)+ is a
+    // hang risk, not just a style problem. Reject the shape before it is ever compiled.
+    if (nestedQuantifier(r.pattern)) return false;
+    try { new RegExp(r.pattern); } catch (e) { return false; }
+  }
+  for (const p of d.prefixes) {
+    if (!p || typeof p.from !== "string" || typeof p.to !== "string") return false;
+    if (p.from.length > 100 || p.to.length > 100) return false;
+  }
+  // featureText is optional, but when present it must be id -> key -> string
+  if (d.featureText !== undefined) {
+    if (!d.featureText || typeof d.featureText !== "object" || Array.isArray(d.featureText)) return false;
+    for (const fid of Object.keys(d.featureText)) {
+      const block = d.featureText[fid];
+      if (!block || typeof block !== "object" || Array.isArray(block)) return false;
+      for (const k of Object.keys(block)) {
+        if (typeof block[k] !== "string" || block[k].length > 400) return false;
+      }
+      if (Object.keys(block).length > 200) return false;
+    }
+  }
+  return true;
+}
+
+function merge(base, extra) {
+  if (!extra) return base;
+  const featureText = Object.assign({}, base.featureText || {}, extra.featureText || {});
+  for (const id of Object.keys(featureText)) {
+    featureText[id] = Object.assign({}, (base.featureText || {})[id] || {}, (extra.featureText || {})[id] || {});
+  }
+  const out = {
+    version: Math.max(base.version || 0, extra.version || 0),
+    language: base.language,
+    clineVersion: extra.clineVersion || base.clineVersion,
+    updated: extra.updated || base.updated,
+    entries: Object.assign({}, base.entries, extra.entries),
+    prefixes: (base.prefixes || []).concat((extra.prefixes || []).filter((p) => !(base.prefixes || []).some((b) => b.from === p.from))),
+    rules: (base.rules || []).concat((extra.rules || []).filter((r) => !(base.rules || []).some((b) => b.pattern === r.pattern)))
+  };
+  if (Object.keys(featureText).length) out.featureText = featureText;
+  return out;
+}
+
+function load(cfgObj) {
+  const name = cfgObj.dictionary || "zh-CN";
+  let dict = readJson(bundledPath(name));
+  if (!dict) throw new Error("bundled dictionary missing: " + name);
+  const cached = readJson(cfg.cachedDictFile(name));
+  if (cached && validate(cached) && cached.version > dict.version) dict = merge(dict, cached);
+  const local = readJson(cfg.localDictFile(name));
+  if (local && local.entries) dict = merge(dict, local);
+  dict.sourceVersions = {
+    bundled: readJson(bundledPath(name))?.version || 0,
+    cached: cached?.version || 0,
+    local: local?.version || 0
+  };
+  return dict;
+}
+
+async function fetchRemote(url, timeoutMs) {
+  const res = await fetch(url, { signal: AbortSignal.timeout(timeoutMs || 12000), cache: "no-store" });
+  if (!res.ok) throw new Error("HTTP " + res.status);
+  return await res.json();
+}
+
+// The configured URL points at the reference dictionary; every locale is a sibling file, so swap
+// the file name rather than asking users to configure one URL per language.
+function remoteUrlFor(cfgObj) {
+  const name = cfgObj.dictionary || "zh-CN";
+  const url = cfgObj.updateUrl || "";
+  return /CHANGE_ME/.test(url) ? url : url.replace(/zh-CN\.json(\?.*)?$/i, name + ".json$1");
+}
+
+// returns { updated, from, to, error }
+async function update(cfgObj, opts) {
+  opts = opts || {};
+  const now = Date.now();
+  if (!opts.force && !cfgObj.autoUpdate) return { updated: false, reason: "autoUpdate disabled" };
+  if (!opts.force && (now - (cfgObj.lastUpdateCheck || 0)) < (cfgObj.updateIntervalMs || 86400000)) {
+    return { updated: false, reason: "not due yet" };
+  }
+  const url = remoteUrlFor(cfgObj);
+  if (!url || /CHANGE_ME/.test(url)) {
+    return { updated: false, reason: "no update url configured" };
+  }
+  cfgObj.lastUpdateCheck = now;
+  const name = cfgObj.dictionary || "zh-CN";
+  try {
+    const remote = await fetchRemote(url);
+    if (!validate(remote)) return { updated: false, error: "remote dictionary failed validation" };
+    if (remote.language && remote.language !== name) {
+      // a 404 page or a mis-pointed URL must not overwrite the locale the user selected
+      return { updated: false, error: "remote dictionary is for " + remote.language + ", not " + name };
+    }
+    const current = load(cfgObj);
+    cfgObj.remoteVersion = remote.version;
+    cfg.write(cfgObj);
+    if (remote.version <= current.version && !opts.force) {
+      return { updated: false, from: current.version, to: remote.version, reason: "already current" };
+    }
+    cfg.ensureDirs();
+    fs.writeFileSync(cfg.cachedDictFile(name), JSON.stringify(remote, null, 1), "utf8");
+    return { updated: true, from: current.version, to: remote.version };
+  } catch (e) {
+    cfg.write(cfgObj);
+    return { updated: false, error: e.message };
+  }
+}
+
+function available() {
+  const dir = path.join(__dirname, "..", "dictionaries");
+  try {
+    return fs.readdirSync(dir).filter((f) => /^[A-Za-z]{2,3}(-[A-Za-z]{2,4})?\.json$/.test(f))
+      .map((f) => f.replace(/\.json$/, ""));
+  } catch (e) { return []; }
+}
+
+module.exports = { load, update, validate, bundledPath, nestedQuantifier, remoteUrlFor, available };

package/src/doctor.js

@@ -0,0 +1,121 @@
+"use strict";
+// doctor.js - one command that answers "is the overlay actually live in the window right now?".
+// Everything else in the tool reports what it *intends*; this reports what the webview *has*,
+// so a Cline update that changes the DOM shows up as a mismatch instead of silent absence.
+const fs = require("fs");
+const cfg = require("./config");
+const cdp = require("./cdp");
+const payload = require("./payload");
+const launcher = require("./launcher");
+const detect = require("./detect");
+
+// Read-only probe. Runs inside the page; returns plain data, never touches the DOM.
+const PROBE = `(function () {
+  var st = window.__clineKitFeatureState || {};
+  var s = window.__ckitStats || { scans: 0, writes: 0, restored: 0 };
+  var out = { engineBuild: window.__ckitEngineBuild || null, stats: { scans: s.scans, writes: s.writes, restored: s.restored }, features: {} };
+  var ids = Object.keys(st).filter(function (k) { return /_build$/.test(k); });
+  ids.forEach(function (k) {
+    var id = k.slice(0, -6);
+    out.features[id] = { build: String(st[k]), stats: st[id + "_stats"] || null };
+  });
+  var rows = document.querySelectorAll("[data-ckit-feat]");
+  out.domRows = rows.length;
+  out.title = document.title || "";
+  return JSON.stringify(out);
+})()`;
+
+function evaluate(api, expression) {
+  return api.rpc("Runtime.evaluate", { expression, returnByValue: true, awaitPromise: false })
+    .then((r) => (r && r.result && r.result.value !== undefined ? r.result.value : null));
+}
+
+async function run() {
+  const conf = cfg.read();
+  const found = detect.detect(conf);
+  const report = { ok: true, checks: [] };
+  const add = (name, pass, detail) => {
+    report.checks.push({ name, pass: !!pass, detail: detail || "" });
+    if (!pass) report.ok = false;
+  };
+
+  add("cline executable", !!found.path, (found.path || "not found") + " (via " + found.source + ")");
+
+  const port = conf.port;
+  const alive = port ? await launcher.isPortAlive(port) : false;
+  add("debug port", !!alive, port ? "127.0.0.1:" + port + (alive ? " responding" : " NOT responding") : "no port in config - run ckit start");
+  if (!alive) {
+    add("injector", !!launcher.injectorRunning(), launcher.injectorRunning() ? "pid " + launcher.injectorRunning() : "not running");
+    report.hint = alive ? "" :
+      "Cline has to be started by cline-kit (it sets WEBVIEW2_ADDITIONAL_BROWSER_ARGUMENTS). " +
+      "If Cline is open but has no debug port, run: ckit start --restart";
+    return report;
+  }
+
+  const current = payload.compose(conf).version;
+  const installed = require("./injector").readActiveVersion();
+  const fresh = installed === current;
+  add("payload version", fresh, (fresh ? "in page " + current : "installed " + (installed || "?") + " but the source builds " + current +
+    " - run: ckit start (it restarts an injector whose code or dictionary went stale underneath it)"));
+
+  const pages = await cdp.eachPage(port, async (api) => {
+    const raw = await evaluate(api, PROBE);
+    try { return JSON.parse(raw); } catch (e) { return null; }
+  });
+  const live = pages.map((p) => p.result).filter(Boolean);
+  add("page reachable", live.length > 0, live.length + " of " + pages.length + " webview target(s) answered");
+
+  const info = payload.info(conf);
+  for (const f of info.features) {
+    if (!f.enabled) continue;
+    const seen = live.map((p) => p.features[f.id]).filter(Boolean);
+    add("feature " + f.id, seen.length > 0, seen.length
+      ? seen.map((s) => "build " + s.build + (s.stats ? ", " + s.stats.rows + " row(s) added of " + s.stats.registered + " registered, " + s.stats.nativeGroups + " native" : "")).join(" | ")
+      : "not present in any page - Cline's DOM may have changed");
+  }
+
+  // Idle-page write rate: an overlay that keeps rewriting nodes is chasing its own mutations, which
+  // freezes the webview long before anything looks wrong on screen.
+  const writesBefore = live.map((p) => p.stats && p.stats.writes).filter((v) => typeof v === "number");
+  await new Promise((r) => setTimeout(r, 3000));
+  const again = (await cdp.eachPage(port, async (api) => {
+    const raw = await evaluate(api, PROBE);
+    try { return JSON.parse(raw); } catch (e) { return null; }
+  })).map((p) => p.result).filter(Boolean);
+  const writesAfter = again.map((p) => p.stats && p.stats.writes).filter((v) => typeof v === "number");
+  const delta = writesBefore.length && writesAfter.length ? writesAfter[0] - writesBefore[0] : 0;
+  add("overlay write rate", delta < 300, delta + " DOM writes over 3 s on an idle page" +
+    (delta >= 300 ? " - the overlay looks to be reacting to its own mutations" : ""));
+
+  const eng = live.map((p) => p.engineBuild).filter(Boolean);
+  add("locale engine", eng.length > 0, eng.length ? "build " + eng[0] + ", dictionary v" + info.dictionaryVersion : "not installed");
+  add("dictionary", info.entries > 0, info.entries + " entries, " + info.rules + " rules"
+    + " (bundled " + info.sources.bundled + ", cached " + info.sources.cached +
+    ", local " + info.sources.local + ")");
+
+  // Once install() repoints a shortcut its target is wscript.exe, so the exe scan finds nothing;
+  // the list recorded at install time is what tells us the wiring exists.
+  const wired = (conf.originalShortcuts || []).filter((s) => s && s.lnk);
+  if (wired.length) {
+    const missing = wired.filter((s) => !fs.existsSync(s.lnk));
+    add("shortcuts", missing.length === 0, missing.length
+      ? missing.length + " of " + wired.length + " recorded shortcut(s) no longer exist (Cline was reinstalled?) - run ckit install"
+      : wired.length + " shortcut(s) go through the cline-kit launcher");
+  } else {
+    add("shortcuts", true, "not repointed - run ckit install to launch Cline through the overlay");
+  }
+  return report;
+}
+
+function format(r) {
+  const lines = r.checks.map((c) => (c.pass ? "  ok   " : "  FAIL ") + c.name + (c.detail ? "  -  " + c.detail : ""));
+  if (r.hint) lines.push("  -> " + r.hint);
+  return (r.ok ? "Cline-kit looks healthy\n" : "Cline-kit needs attention\n") + lines.join("\n");
+}
+
+module.exports = { run, format, PROBE };
+
+if (require.main === module) {
+  run().then((r) => { console.log(format(r)); process.exitCode = r.ok ? 0 : 1; })
+    .catch((e) => { console.error("doctor: " + e.message); process.exit(1); });
+}

package/src/engine.js

@@ -0,0 +1,148 @@
+/* cline-kit overlay engine (browser side).
+ * Runs inside the Cline webview. Expects a `DICT` const in scope:
+ *   { version, entries: {en: zh}, prefixes: [{from,to}], rules: [{pattern,out}] }
+ * No dependencies, no network, no eval of remote code beyond this data.
+ */
+(function () {
+  var VER = (DICT && DICT.version) || 1;
+  // Guard on the engine build *and* the dictionary version. Engine-only edits must re-run, and so
+  // must a locale switch or `ckit update`: those change DICT while this file stays byte-identical.
+  var BUILD = String((DICT && DICT.engineBuild) || "v" + VER) + "/d" + VER + "/" + (DICT && DICT.language);
+  if (window.__ckitEngineBuild === BUILD) return;
+  if (window.__ckitObserver) { try { window.__ckitObserver.disconnect(); } catch (e) { } }
+  if (window.__ckitTimer) { clearInterval(window.__ckitTimer); }
+  window.__ckitEngineBuild = BUILD;
+  window.__ckitEngineVersion = VER;
+
+  var ENTRIES = DICT.entries || {};
+  var PREFIXES = DICT.prefixes || [];
+  var RULES = (DICT.rules || []).map(function (r) {
+    try { return { re: new RegExp(r.pattern), out: r.out }; } catch (e) { return null; }
+  }).filter(Boolean);
+
+  function expand(str, m) {
+    return str.replace(/\$(\d)/g, function (_, n) { return m[+n] === undefined ? "" : m[+n]; });
+  }
+
+  function lookup(s) {
+    if (!s) return null;
+    var hit = ENTRIES[s];
+    if (hit) return hit;
+    for (var i = 0; i < RULES.length; i++) {
+      var m = s.match(RULES[i].re);
+      if (m) {
+        var r = expand(RULES[i].out, m);
+        if (r && r !== s) return r;
+      }
+    }
+    for (var j = 0; j < PREFIXES.length; j++) {
+      var from = PREFIXES[j].from, to = PREFIXES[j].to;
+      if (s.length > from.length && s.slice(0, from.length) === from) return to + s.slice(from.length);
+    }
+    return null;
+  }
+
+  var ATTRS = (DICT.attributes || ["placeholder", "aria-label", "title"]);
+  var SKIP = { SCRIPT: 1, STYLE: 1, TEXTAREA: 1, CODE: 1, PRE: 1, SVG: 1 };
+  var CJK = /[一-鿿]/;
+  var LATIN = /[A-Za-z]{3}/;
+
+  // Write counter: an overlay that keeps rewriting the same nodes is chasing its own mutations,
+  // which shows up as a frozen webview long before it shows up as a visual bug. `ckit doctor`
+  // samples this twice and fails when an idle page keeps taking writes.
+  var STATS = window.__ckitStats = { scans: 0, writes: 0, restored: 0 };
+
+  function norm(s) { return String(s || "").replace(/\s+/g, " ").trim(); }
+
+  // Text we replaced is remembered on the node, so switching locale (or pulling a newer dictionary)
+  // can start from the original English instead of from last run's output.
+  function translateText(node) {
+    var raw = node.nodeValue;
+    if (!raw || raw.length > 800) return;
+    var el = node.parentElement;
+    if (el && SKIP[el.tagName]) return;
+    var src = raw;
+    if (node.__ckitOut != null) {
+      src = norm(raw) === norm(node.__ckitOut) ? node.__ckitSrc : raw;  // the app rewrote it: stale
+    }
+    var key = norm(src);
+    if (key.length < 2) return;
+    if (node.__ckitSrc == null && (CJK.test(key) || !LATIN.test(key))) return;
+    var rep = lookup(key);
+    var lead = raw.match(/^\s*/)[0];
+    var trail = raw.match(/\s*$/)[0];
+    if (!rep || rep === src) {
+      if (node.__ckitSrc != null) { node.nodeValue = lead + node.__ckitSrc + trail; node.__ckitSrc = null; node.__ckitOut = null; STATS.restored++; }
+      return;
+    }
+    node.__ckitSrc = src;
+    node.__ckitOut = rep;
+    // Never write an identical value: our own mutation would wake the observer again and the two
+    // would chase each other forever (that is a frozen webview, not a slow one).
+    var next = lead + rep + trail;
+    if (next !== raw) { node.nodeValue = next; STATS.writes++; }
+  }
+
+  function translateEl(el) {
+    if (!el || el.nodeType !== 1 || !el.getAttribute) return;
+    var keep = el.__ckitAttrSrc || (el.__ckitAttrSrc = {});
+    for (var i = 0; i < ATTRS.length; i++) {
+      var a = ATTRS[i];
+      var v = el.getAttribute(a);
+      if (!v && keep[a] == null) continue;
+      var src = keep[a] != null && norm(v) === norm(keep[a].out) ? keep[a].src : v;
+      var rep = lookup(norm(src));
+      if (!rep || rep === src) {
+        if (keep[a]) { el.setAttribute(a, keep[a].src); delete keep[a]; STATS.restored++; }
+        continue;
+      }
+      keep[a] = { src: src, out: rep };
+      if (rep !== v) { el.setAttribute(a, rep); STATS.writes++; }
+    }
+  }
+
+  function scan(root) {
+    var el = root && root.nodeType ? root : document.documentElement;
+    if (!el) return;
+    try {
+      STATS.scans++;
+      var w = document.createTreeWalker(el, NodeFilter.SHOW_TEXT | NodeFilter.SHOW_ELEMENT, null, false);
+      var n;
+      while ((n = w.nextNode())) {
+        if (n.nodeType === 3) translateText(n);
+        else translateEl(n);
+      }
+    } catch (e) { /* DOM raced away; next pass will catch it */ }
+  }
+
+  var queued = false;
+  function schedule() {
+    if (queued) return;
+    queued = true;
+    var run = function () { queued = false; scan(document.documentElement); };
+    (window.requestAnimationFrame || setTimeout)(run, 16);
+  }
+
+  if (!document.documentElement) return;
+  scan(document.documentElement);
+
+  window.__ckitObserver = new MutationObserver(function (muts) {
+    for (var i = 0; i < muts.length; i++) {
+      var m = muts[i];
+      if (m.type === "characterData") { translateText(m.target); continue; }
+      if (m.type === "attributes") { translateEl(m.target); continue; }
+      for (var j = 0; j < m.addedNodes.length; j++) scan(m.addedNodes[j]);
+    }
+    schedule();
+  });
+  window.__ckitObserver.observe(document.documentElement, {
+    childList: true, subtree: true, characterData: true,
+    attributes: true, attributeFilter: ATTRS
+  });
+
+  // safety net for portals/menus mounted outside the observed subtree
+  window.__ckitTimer = setInterval(function () { scan(document.documentElement); }, 1200);
+
+  window.__zhUIStats = { version: VER, entries: Object.keys(ENTRIES).length };
+  try { console.log("[cline-kit] overlay v" + VER + " loaded (" + Object.keys(ENTRIES).length + " entries)"); } catch (e) { }
+})();

package/src/features/index.js

@@ -0,0 +1,83 @@
+"use strict";
+// Feature registry. Each feature is a self-contained browser script in this folder.
+// Versions are read from the scripts themselves so the registry cannot drift.
+const fs = require("fs");
+const path = require("path");
+
+const DEFS = [
+  {
+    id: "sidebar-groups",
+    // shared logic first, then the browser script that consumes window.__ckitSidebarLogic
+    parts: ["sidebar-groups.logic.js", "sidebar-groups.js"],
+    title: "Keep every registered project in the sidebar / 侧边栏全项目常驻",
+    defaultOn: true,
+    // config handed to the browser script; keep it JSON-serialisable
+    build(ctx) {
+      return {
+        installDir: ctx.installDir || "",
+        hide: ctx.cfg.featureHide || [],
+        maxRows: 80,
+        groupMode: true,
+        // leave empty to follow Cline's own cline.code.workspace-selection.vN key
+        storageKey: ctx.cfg.storageKey || "",
+        text: (ctx.featureText || {})[this.id] || {}
+      };
+    }
+  }
+];
+
+function scriptVersion(src) {
+  const m = src.match(/var\s+VER\s*=\s*(\d+)/) || src.match(/const\s+VER\s*=\s*(\d+)/);
+  return m ? Number(m[1]) : 1;
+}
+
+function filesOf(def) { return def.parts || [def.file]; }
+
+function readSource(def) {
+  const list = filesOf(def);
+  const src = list.map((f) => fs.readFileSync(path.join(__dirname, f), "utf8")).join("\n");
+  const main = fs.readFileSync(path.join(__dirname, list[list.length - 1]), "utf8");
+  return { src, version: scriptVersion(main), path: path.join(__dirname, list[0]) };
+}
+
+function list() {
+  return DEFS.map((d) => {
+    let version = 0;
+    try { version = readSource(d).version; } catch (e) { version = -1; }
+    return { id: d.id, title: d.title, version, defaultOn: d.defaultOn };
+  });
+}
+
+function enabledSet(cfgObj) {
+  const out = {};
+  for (const d of DEFS) out[d.id] = d.defaultOn;
+  const fromCfg = cfgObj.features || {};
+  for (const k of Object.keys(fromCfg)) {
+    if (k in out) out[k] = !!fromCfg[k];
+  }
+  return out;
+}
+
+function resolve(cfgObj, dictObj) {
+  const on = enabledSet(cfgObj);
+  const ctx = {
+    cfg: cfgObj,
+    installDir: cfgObj.clinePath ? path.dirname(cfgObj.clinePath) : "",
+    featureText: (dictObj && dictObj.featureText) || {}
+  };
+  const picked = [];
+  for (const d of DEFS) {
+    if (!on[d.id]) continue;
+    let entry;
+    try {
+      entry = readSource(d);
+    } catch (e) {
+      entry = null;
+    }
+    if (!entry) continue;
+    picked.push({ id: d.id, version: entry.version, source: entry.src, config: d.build(ctx) });
+  }
+  return { picked, enabled: on };
+}
+
+module.exports = { list, resolve, enabledSet, DEFS };