cline-kit 0.1.0

package/src/features/sidebar-groups.js

@@ -0,0 +1,376 @@
+// feature: sidebar-groups
+// Shows every registered Cline workspace in the sidebar's project grouping, not just the ones that
+// already have sessions. Native Cline hides empty projects; this appends them with the same styling
+// and switches project by driving Cline's own workspace picker (chip -> search -> result row).
+//
+// Runs inside the webview. Config arrives as window.__clineKitFeature["sidebar-groups"].
+(function () {
+  var ID = "sidebar-groups";
+  var VER = 6;                       // human-readable; hot-swap keys off CFG.__build instead
+  var CFG = (window.__clineKitFeature && window.__clineKitFeature[ID]) || {};
+  var st = window.__clineKitFeatureState = window.__clineKitFeatureState || {};
+  var BUILD = String(CFG.__build || "v" + VER);
+  if (st[ID + "_build"] === BUILD) return;
+  if (st[ID + "_observer"]) { try { st[ID + "_observer"].disconnect(); } catch (e) { } }
+  if (st[ID + "_timer"]) clearInterval(st[ID + "_timer"]);
+  st[ID + "_build"] = BUILD;
+  st[ID] = VER;
+
+  // Pure path/filtering helpers live in a sibling file that is prepended to this script by
+  // src/features/index.js and unit tested in scripts/selftest.js.
+  var L = window.__ckitSidebarLogic;
+  if (!L) {
+    try { console.warn("[cline-kit:" + ID + "] logic module missing, feature disabled"); } catch (e) { }
+    return;
+  }
+  var INSTALL = (CFG.installDir || "");
+  var HIDE = (CFG.hide || []);
+  var MAX_ROWS = CFG.maxRows || 80;
+  var TEXT = CFG.text || {};
+  // Fallbacks are English on purpose: English is the app source language, so a feature stays
+  // readable when a locale has no featureText block yet. Translations arrive via CFG.text,
+  // which the registry fills from dictionaries/<locale>.json -> featureText[<id>].
+
+  var CHEVRON = "lucide lucide-chevron-down size-3.5 shrink-0 transition-transform";
+  var HEAD_CLS = "flex h-8 w-full min-w-0 items-center gap-1.5 rounded-md px-1 text-left text-sm font-medium text-sidebar-foreground hover:bg-surface-hover-lighter focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-sidebar-ring";
+  var ACT_CLS = "flex h-7 w-full min-w-0 items-center gap-1.5 rounded-md px-1 text-left text-xs text-muted-foreground hover:bg-surface-hover-lighter hover:text-sidebar-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-sidebar-ring";
+
+  function t(key, fallback) { return (TEXT && TEXT[key]) || fallback; }
+
+  var norm = L.norm;
+  var base = L.base;
+  var strip = L.strip;
+  var KEY = CFG.storageKey || L.registryKey(storageKeys()) || "cline.code.workspace-selection.v2";
+
+  function storageKeys() {
+    var out = [];
+    for (var i = 0; i < localStorage.length; i++) {
+      var k = localStorage.key(i);
+      if (k) out.push(k);
+    }
+    return out;
+  }
+
+  function registry() {
+    var parsed = L.parseRegistry(localStorage.getItem(KEY));
+    parsed.key = KEY;
+    return parsed;
+  }
+
+  function listRoot() {
+    var vp = document.querySelector("[data-radix-scroll-area-viewport]");
+    if (!vp) return null;
+    var box = vp.querySelector('div[class*="flex-col"]');
+    return box && box.querySelector('button[aria-expanded]') ? box : (box || null);
+  }
+
+  // Labels of the groups Cline already renders; used so we never add a row for a project that is
+  // already on screen.
+  function nativeLabels(box) {
+    var out = [];
+    if (!box) return out;
+    var bs = box.querySelectorAll('button[aria-expanded]');
+    for (var i = 0; i < bs.length; i++) {
+      var b = bs[i];
+      if (!/h-8 w-full/.test(b.className)) continue;
+      if (b.closest("[data-ckit-feat]")) continue; // our own rows must not hide our own rows
+      var sp = b.querySelector("span");
+      var name = norm(sp ? sp.textContent : b.textContent);
+      if (name && out.indexOf(name) < 0) out.push(name);
+    }
+    return out;
+  }
+
+  function waitFor(fn, ms) {
+    return new Promise(function (resolve) {
+      var t0 = Date.now();
+      (function loop() {
+        var v = null;
+        try { v = fn(); } catch (e) { }
+        if (v) return resolve(v);
+        if (Date.now() - t0 > (ms || 2500)) return resolve(null);
+        setTimeout(loop, 80);
+      })();
+    });
+  }
+
+  function setNativeValue(inp, val) {
+    var d = Object.getOwnPropertyDescriptor(window.HTMLInputElement.prototype, "value");
+    if (d && d.set) d.set.call(inp, val); else inp.value = val;
+    inp.dispatchEvent(new Event("input", { bubbles: true }));
+    inp.dispatchEvent(new Event("change", { bubbles: true }));
+  }
+
+  // The workspace chip lives in the title bar, outside the sidebar list. Match structurally rather
+  // than by pixel offset: the sidebar can be resized, docked or narrowed to icons.
+  function inSidebar(el) {
+    return !!(el.closest && (el.closest('[class*="bg-sidebar"]') || el.closest("nav")));
+  }
+
+  function findChip(labels) {
+    var wanted = {};
+    (labels || []).forEach(function (l) { wanted[l] = 1; });
+    var btns = [].slice.call(document.querySelectorAll("button")).filter(function (e) {
+      var r = e.getBoundingClientRect();
+      return r.width > 0 && !inSidebar(e) && wanted[norm(e.textContent)] && !!e.querySelector("svg");
+    });
+    return btns[0] || null;
+  }
+
+  function findRow(path) {
+    var want = norm(path);
+    var all = [].slice.call(document.querySelectorAll("button")).filter(function (e) {
+      return norm(e.textContent) === want;
+    });
+    if (!all.length) return null;
+    var inList = all.filter(function (e) {
+      return /max-h-\d+/.test((e.parentElement || {}).className || "");
+    });
+    return inList[inList.length - 1] || all[all.length - 1];
+  }
+
+  var switching = false;
+  function switchWorkspace(path) {
+    if (switching) return Promise.resolve();
+    switching = true;
+    var prev = document.activeElement;
+    var chip = findChip(L.labelize(registry().workspaces).map(function (e) { return e.label; }));
+    var done = function (msg) {
+      switching = false;
+      setTimeout(render, 250);
+      setTimeout(render, 1200);
+      if (prev && prev.focus) { try { prev.focus(); } catch (e) { } }
+      if (msg) flash(msg);
+      return Promise.resolve();
+    };
+    if (!chip) return done(t("errNoChip", "Could not find the workspace button"));
+    chip.click();
+    return waitFor(function () {
+      var ins = document.querySelectorAll("input");
+      for (var i = 0; i < ins.length; i++) {
+        if (/搜索工作区|search workspace|enter a folder path/i.test(ins[i].getAttribute("placeholder") || "")) return ins[i];
+      }
+      return null;
+    }, 2000).then(function (inp) {
+      if (!inp) { chip.click(); return done(t("errNoSearch", "Could not find the workspace search box")); }
+      setNativeValue(inp, path);
+      return waitFor(function () { return findRow(path); }, 2200).then(function (row) {
+        if (!row) {
+          ["keydown", "keyup"].forEach(function (type) {
+            inp.dispatchEvent(new KeyboardEvent(type, { key: "Escape", code: "Escape", bubbles: true }));
+          });
+          return done(t("errNotListed", "That project is not in the list"));
+        }
+        row.click();
+        return done(null);
+      });
+    }).catch(function () { return done(t("errSwitch", "Switch failed")); });
+  }
+
+  var flashMsg = "";
+  function flash(msg) {
+    flashMsg = msg;
+    render();
+    setTimeout(function () { flashMsg = ""; render(); }, 2600);
+  }
+
+  var SVG_CHEVRON = '<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="m6 9 6 6 6-6"></path></svg>';
+  var SVG_FOLDER = '<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M4 20h16a2 2 0 0 0 2-2V8a2 2 0 0 0-2-2h-7.9a2 2 0 0 1-1.69-.9L9.6 3.9A2 2 0 0 0 7.93 3H4a2 2 0 0 0-2 2v13c0 1.1.9 2 2 2Z"></path></svg>';
+
+  // static markup only; every dynamic value goes through textContent
+  function svgInto(el, markup, cls) {
+    el.innerHTML = markup;
+    var node = el.firstElementChild;
+    if (node && cls) node.setAttribute("class", cls);
+    return node;
+  }
+
+  function span(cls, text) {
+    var s = document.createElement("span");
+    if (cls) s.className = cls;
+    s.textContent = text;
+    return s;
+  }
+
+  function buildRow(ws, label, isCurrent) {
+    var wrap = document.createElement("div");
+    wrap.className = "mb-1 min-w-0";
+    wrap.setAttribute("data-ckit-feat", ID);
+    wrap.dataset.wsPath = ws;
+
+    var head = document.createElement("button");
+    head.type = "button";
+    head.className = HEAD_CLS;
+    head.setAttribute("aria-expanded", "false");
+    head.title = ws;                                  // full path: the label may be shortened
+    svgInto(head, SVG_CHEVRON, CHEVRON + " -rotate-90");
+    head.appendChild(span("block min-w-0 truncate", label));
+    if (isCurrent) head.appendChild(span("ml-auto shrink-0 text-[11px] text-muted-foreground", t("current", "current")));
+    wrap.appendChild(head);
+
+    var body = document.createElement("div");
+    body.className = "hidden pl-4";
+    // A bare label means this path is definitely not on screen already (Cline headers show bare
+    // folder names), so "no sessions" is a true statement. A qualified label was disambiguated
+    // against a same-named sibling, and one of them may be the native group above - claim nothing.
+    if (label === base(ws)) {
+      body.appendChild(span("px-1 py-1 text-xs text-muted-foreground", t("noSessions", "No sessions yet")));
+    }
+
+    var act = document.createElement("button");
+    act.type = "button";
+    act.className = ACT_CLS;
+    svgInto(act, SVG_FOLDER, "size-3.5 shrink-0");
+    act.appendChild(span(null, t("switchAndNew", "Open this project and start a session")));
+    act.addEventListener("click", function (ev) { ev.stopPropagation(); switchWorkspace(ws); });
+    body.appendChild(act);
+
+    if (flashMsg) {
+      var err = document.createElement("div");
+      err.className = "px-1 py-1 text-xs text-destructive";
+      err.textContent = flashMsg;
+      body.appendChild(err);
+    }
+    wrap.appendChild(body);
+
+    head.addEventListener("click", function () {
+      var open = head.getAttribute("aria-expanded") === "true";
+      head.setAttribute("aria-expanded", open ? "false" : "true");
+      body.classList.toggle("hidden", open);
+      head.firstElementChild.classList.toggle("-rotate-90", open);
+    });
+    return wrap;
+  }
+
+  function projectMode() {
+    var btns = document.querySelectorAll("button");
+    var headerLabels = {};
+    headerLabels[t("projects", "Projects")] = true;
+    headerLabels["Projects"] = true;
+    var sawSortControl = false;
+    for (var i = 0; i < btns.length; i++) {
+      var a = btns[i].getAttribute("aria-label") || "";
+      // Prefer the sort control's own label: it states the current mode and survives restyling.
+      if (/会话排序|Sort sessions/i.test(a)) {
+        sawSortControl = true;
+        if (/项目|Project/i.test(a)) return true;
+        if (/时间|Time/i.test(a)) return false;
+      }
+      if (headerLabels[norm(btns[i].textContent)]) return true;
+    }
+    if (!sawSortControl) {
+      // no sort control found at all (different Cline build): fall back to the visible header only
+      for (var j = 0; j < btns.length; j++) {
+        if (headerLabels[norm(btns[j].textContent)]) return true;
+      }
+    }
+    return false;
+  }
+
+  // Native grouping mode is not persisted by Cline, so keep it on. We stop interfering the moment
+  // the user touches the sort control themselves - their choice wins for the rest of the session,
+  // but a mode flip caused by anything else (React state churn, another overlay, a workspace switch
+  // that rebuilds the window) is corrected on the next tick instead of leaving the feature off.
+  var userTouchedSort = false;
+  function sortButton() {
+    var btns = document.querySelectorAll("button");
+    for (var i = 0; i < btns.length; i++) {
+      var a = btns[i].getAttribute("aria-label") || "";
+      if (/会话排序|Sort sessions/i.test(a)) return btns[i];
+    }
+    return null;
+  }
+  document.addEventListener("click", function (ev) {
+    var t = ev.target;
+    if (!t || !t.closest) return;
+    var b = t.closest("button");
+    if (b && /会话排序|Sort sessions/i.test(b.getAttribute("aria-label") || "")) userTouchedSort = true;
+  }, true);
+
+  var lastAutoClick = 0;
+  function ensureProjectMode() {
+    if (userTouchedSort || CFG.groupMode === false) return;
+    if (projectMode()) return;
+    // cooldown so a detection mismatch cannot turn into a click loop every tick
+    if (Date.now() - lastAutoClick < 6000) return;
+    var btn = sortButton();
+    if (btn) { lastAutoClick = Date.now(); btn.click(); setTimeout(render, 300); }
+  }
+
+  var sig = "";
+  function render() {
+    ensureProjectMode();
+    var box = listRoot();
+    if (!box || !projectMode()) { clearRows(); sig = ""; return; }
+    var reg = registry();
+    var currentPath = strip(reg.last).toLowerCase();
+    var missing = L.plan(reg.workspaces, nativeLabels(box), {
+      maxRows: MAX_ROWS, installDir: INSTALL, hide: HIDE
+    });
+    var s = missing.map(function (e) { return e.path + "=" + e.label; }).join("|") + "::" + currentPath + "::" + flashMsg;
+    // Self-heal: compare what we intended against what is actually in the DOM. If anything rewrote
+    // or dropped our labels (React reconciliation, another overlay, a partial render), rebuild.
+    var dom = [];
+    var ours = box.querySelectorAll(":scope > [data-ckit-feat]");
+    for (var k = 0; k < ours.length; k++) {
+      var sp = ours[k].querySelector("span");
+      dom.push((ours[k].dataset.wsPath || "") + "=" + (sp ? sp.textContent : ""));
+    }
+    var want = missing.map(function (e) { return e.path + "=" + e.label; }).join("|");
+    if (s === sig && dom.join("|") === want) { report(box, ours.length, missing.length, reg); return; }
+    sig = s;
+    clearRows();
+    if (missing.length) {
+      var frag = document.createDocumentFragment();
+      for (var j = 0; j < missing.length; j++) {
+        frag.appendChild(buildRow(missing[j].path, missing[j].label, strip(missing[j].path).toLowerCase() === currentPath));
+      }
+      box.appendChild(frag);
+    }
+    report(box, box.querySelectorAll(":scope > [data-ckit-feat]").length, missing.length, reg);
+  }
+
+  // Counters for `ckit doctor`: what the feature believes right now, readable from outside the
+  // closure through window.__clineKitFeatureState.
+  function report(box, rows, intended, reg) {
+    var native = 0;
+    var all = box.querySelectorAll('button[aria-expanded]');
+    for (var i = 0; i < all.length; i++) {
+      if (/h-8 w-full/.test(all[i].className) && !all[i].closest("[data-ckit-feat]")) native++;
+    }
+    st[ID + "_stats"] = {
+      version: VER, build: BUILD, registered: reg.workspaces.length,
+      nativeGroups: native, intended: intended, rows: rows, mode: "project"
+    };
+  }
+
+  function clearRows() {
+    var box = listRoot();
+    if (!box) return;
+    var olds = box.querySelectorAll(":scope > [data-ckit-feat]");
+    for (var i = 0; i < olds.length; i++) olds[i].remove();
+  }
+
+  var queued = false;
+  function schedule() {
+    if (queued) return;
+    queued = true;
+    (window.requestAnimationFrame || setTimeout)(function () { queued = false; render(); }, 16);
+  }
+
+  if (!document.body) return;
+  render();
+  st[ID + "_observer"] = new MutationObserver(function (muts) {
+    for (var i = 0; i < muts.length; i++) {
+      var n = muts[i].target;
+      if (n && n.nodeType === 3) n = n.parentElement;
+      if (n && n.closest && n.closest("[data-ckit-feat]")) continue;
+    }
+    schedule();
+  });
+  st[ID + "_observer"].observe(document.documentElement, {
+    childList: true, subtree: true, attributes: true, attributeFilter: ["class", "aria-expanded"]
+  });
+  st[ID + "_timer"] = setInterval(render, 1500);
+  try { console.log("[cline-kit:" + ID + "] loaded v" + VER); } catch (e) { }
+})();

package/src/features/sidebar-groups.logic.js

@@ -0,0 +1,145 @@
+// Pure helpers for the sidebar-groups feature: no DOM, no browser globals.
+// Loaded twice from the same file - CommonJS for scripts/selftest.js, and prepended to the
+// browser script by src/features/index.js, where it lands on window.__ckitSidebarLogic.
+(function (root, factory) {
+  if (typeof module === "object" && module.exports) module.exports = factory();
+  else if (root) root.__ckitSidebarLogic = factory();
+})(typeof window !== "undefined" ? window : this, function () {
+  "use strict";
+
+  var SEP = /[\\/]/;
+
+  // Collapse every run of whitespace (space, tab, newline) to one space. React renders the same
+  // label with newlines between children, so without this nothing ever matches.
+  function norm(s) { return (s == null ? "" : String(s)).replace(/\s+/g, " ").trim(); }
+
+  function strip(p) { return String(p == null ? "" : p).replace(/[\\/]+$/, ""); }
+
+  function lastSep(s) {
+    var i = -1;
+    for (var k = 0; k < s.length; k++) if (SEP.test(s[k])) i = k;
+    return i;
+  }
+
+  function base(p) {
+    var s = strip(p);
+    var i = lastSep(s);
+    return i >= 0 ? s.slice(i + 1) : s;
+  }
+
+  function dirname(p) {
+    var s = strip(p);
+    var i = lastSep(s);
+    return i >= 0 ? s.slice(0, i) : "";
+  }
+
+  // The folder holding this project, used to tell two same-named projects apart.
+  function parent(p) { return base(dirname(p)); }
+
+  function samePath(a, b) { return strip(a).toLowerCase() === strip(b).toLowerCase(); }
+
+  // "p is at or under root". Case-insensitive for drive-letter paths, and separator-aware so
+  // "D:\Cl" is not treated as a parent of "D:\Cline".
+  function isUnder(p, rootPath) {
+    var a = strip(p), b = strip(rootPath);
+    if (!a || !b) return false;
+    if (/^[A-Za-z]:[\\/]/.test(a) || /^[A-Za-z]:[\\/]/.test(b)) { a = a.toLowerCase(); b = b.toLowerCase(); }
+    if (a === b) return true;
+    return a.indexOf(b + "\\") === 0 || a.indexOf(b + "/") === 0;
+  }
+
+  // Cline stores its workspace registry under a versioned key; follow the highest one present so a
+  // v3 bump does not silently read an empty list.
+  var REGISTRY_KEY_RE = /^cline\.code\.workspace-selection\.v(\d+)$/;
+  function registryKey(keys) {
+    var best = null, bestVer = -1;
+    for (var i = 0; i < (keys || []).length; i++) {
+      var m = REGISTRY_KEY_RE.exec(keys[i]);
+      if (m) { var v = Number(m[1]); if (v > bestVer) { bestVer = v; best = keys[i]; } }
+    }
+    return best;
+  }
+
+  function parseRegistry(raw) {
+    try {
+      var obj = JSON.parse(raw || "{}");
+      var env = ((obj.environments || {}).local) || {};
+      var ws = Array.isArray(env.workspaces)
+        ? env.workspaces.filter(function (x) { return typeof x === "string" && x.trim(); })
+        : [];
+      return { workspaces: ws, last: typeof env.lastWorkspace === "string" ? env.lastWorkspace : "" };
+    } catch (e) { return { workspaces: [], last: "" }; }
+  }
+
+  // A registered path is a container rather than a project when another registered path sits
+  // inside it, when it is the app's own install directory, or when the user hid it.
+  function isContainer(p, all, opts) {
+    opts = opts || {};
+    var clean = strip(p);
+    for (var i = 0; i < (all || []).length; i++) {
+      if (!samePath(all[i], clean) && isUnder(all[i], clean)) return true;
+    }
+    var install = strip(opts.installDir || "");
+    if (install && isUnder(clean, install)) return true;
+    var hide = opts.hide || [];
+    for (var k = 0; k < hide.length; k++) {
+      if (hide[k] && isUnder(clean, hide[k])) return true;
+    }
+    return false;
+  }
+
+  // Unique names show as-is; a collision adds the parent folder, "LLM (workspace)"; and if that
+  // still collides, a counter. Labels are unique by construction, so the sidebar never shows two
+  // indistinguishable rows - the tooltip carries the full path either way.
+  function labelize(paths) {
+    var counts = {};
+    (paths || []).forEach(function (p) { var b = base(p) || p; counts[b] = (counts[b] || 0) + 1; });
+    var used = {};
+    return (paths || []).map(function (p) {
+      var b = base(p) || p;
+      var label = counts[b] > 1 ? b + " (" + (parent(p) || "/") + ")" : b;
+      var n = 2;
+      while (used[label]) label = b + " (" + n++ + ")";
+      used[label] = true;
+      return { path: p, label: label };
+    });
+  }
+
+  // Which labelled projects still need a row: skip ones the native UI already shows (matched on the
+  // displayed label, so a same-named-but-different project still appears), containers, and repeats.
+  function pickMissing(entries, nativeLabels, opts) {
+    opts = opts || {};
+    var max = typeof opts.maxRows === "number" ? opts.maxRows : 80;
+    var have = {};
+    (nativeLabels || []).forEach(function (x) { have[x] = true; });
+    var out = [], seenLabel = {}, seenPath = {};
+    var list = entries || [];
+    for (var i = 0; i < list.length && out.length < max; i++) {
+      var e = list[i];
+      if (!e || !e.path || !e.label) continue;
+      if (have[e.label] || seenLabel[e.label] || seenPath[e.path]) continue;
+      if (isContainer(e.path, list.map(function (x) { return x.path; }), opts)) continue;
+      seenLabel[e.label] = true;
+      seenPath[e.path] = true;
+      out.push(e);
+    }
+    return out;
+  }
+
+  // Convenience for callers that start from raw paths: containers are removed before labelling,
+  // so a container never steals a nice label from a real project.
+  function plan(workspaces, nativeLabels, opts) {
+    opts = opts || {};
+    var kept = (workspaces || []).filter(function (p) {
+      return norm(p) && !isContainer(p, workspaces, opts);
+    });
+    var seen = {};
+    kept = kept.filter(function (p) { if (seen[p]) return false; seen[p] = true; return true; });
+    return pickMissing(labelize(kept), nativeLabels, opts);
+  }
+
+  return {
+    norm, strip, base, parent, dirname, samePath, isUnder,
+    registryKey, parseRegistry, isContainer, labelize, pickMissing, plan
+  };
+});

package/src/injector.js

@@ -0,0 +1,96 @@
+"use strict";
+// Resident keep-alive: keeps the overlay installed in every Cline webview page.
+// Re-reads the dictionary each cycle, so `ckit update` takes effect without a restart.
+const fs = require("fs");
+const path = require("path");
+const { execFileSync } = require("child_process");
+const cfg = require("./config");
+const cdp = require("./cdp");
+const payload = require("./payload");
+
+const INTERVAL_MS = 4000;
+const registered = new Map(); // targetId -> { scriptId, dictVersion }
+
+// Surface injection failures instead of swallowing them; a silent no-op is the worst outcome.
+function log(msg) {
+  try {
+    cfg.ensureDirs();
+    fs.appendFileSync(path.join(cfg.logDir(), "injector.log"),
+      new Date().toISOString() + " " + msg + "\n");
+  } catch (e) { /* never fail the loop over logging */ }
+}
+
+function clineRunning() {
+  if (process.platform !== "win32") return true;
+  try {
+    const out = execFileSync("tasklist.exe", ["/FI", "IMAGENAME eq cline-app.exe", "/NH"], { encoding: "utf8" });
+    return /cline-app\.exe/i.test(out);
+  } catch (e) {
+    return true; // never exit on a transient query failure while a port still answers
+  }
+}
+
+async function installOnce(port, source, version) {
+  const results = await cdp.eachPage(port, async (api, target) => {
+    await api.rpc("Runtime.enable");
+    await api.rpc("Page.enable");
+    const prev = registered.get(target.id);
+    if (!prev || prev.dictVersion !== version) {
+      if (prev) {
+        try { await api.rpc("Page.removeScriptToEvaluateOnNewDocument", { identifier: prev.scriptId }); } catch (e) { }
+      }
+      const r = await api.rpc("Page.addScriptToEvaluateOnNewDocument", { source });
+      registered.set(target.id, { scriptId: r.identifier, dictVersion: version });
+    }
+    const r = await api.rpc("Runtime.evaluate", { expression: source });
+    if (r && r.exceptionDetails) {
+      const ex = r.exceptionDetails.exception || {};
+      log("evaluate error on " + target.id + ": " + (ex.description || ex.value || r.exceptionDetails.text));
+    }
+    return true;
+  });
+  return results;
+}
+
+// The injector is a long-lived process, so editing src/*.js does not affect a running one.
+// It records the payload version it actually installed; ckit start compares that with the
+// current version and restarts a stale injector (otherwise `git pull` appears to do nothing).
+function activeVersionFile() { return path.join(cfg.cacheDir(), "active-version"); }
+
+function readActiveVersion() {
+  try { return fs.readFileSync(activeVersionFile(), "utf8").trim(); } catch (e) { return ""; }
+}
+
+function writeActiveVersion(v) {
+  if (readActiveVersion() === v) return;
+  try { cfg.ensureDirs(); fs.writeFileSync(activeVersionFile(), v); } catch (e) { /* best effort */ }
+}
+
+async function main() {
+  const boot = cfg.read();
+  const port = boot.port;
+  if (!port) {
+    console.error("[cline-kit] injector: no port in config; start via `ckit start`");
+    process.exit(2);
+  }
+  let gone = 0;
+  for (;;) {
+    try {
+      // re-read every cycle so feature toggles, dictionary updates and path changes apply live
+      const conf = cfg.read();
+      const composed = payload.compose(conf);
+      await installOnce(conf.port || port, composed.source, composed.version);
+      writeActiveVersion(composed.version);
+      gone = 0;
+    } catch (e) {
+      if (!clineRunning() && ++gone > 3) {
+        console.log("[cline-kit] cline is gone; injector exiting");
+        return;
+      }
+    }
+    await new Promise((r) => setTimeout(r, INTERVAL_MS));
+  }
+}
+
+if (require.main === module) main().catch((e) => { console.error(e); process.exit(1); });
+module.exports = { installOnce, readActiveVersion, activeVersionFile };