cline-kit 0.1.0

package/src/install-win.js

@@ -0,0 +1,155 @@
+"use strict";
+// Windows integration: a no-console launcher + repointing the user's Cline shortcut.
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const { execFileSync } = require("child_process");
+const cfg = require("./config");
+
+const VBS = (ps1) => `' cline-kit launcher - starts the Cline desktop app with the enhancement overlay
+Set sh = CreateObject("WScript.Shell")
+sh.Run "powershell.exe -NoProfile -ExecutionPolicy Bypass -WindowStyle Hidden -File ""${ps1}""", 0, False
+`;
+
+const PS1 = (nodeExe, argsString) => `# cline-kit launcher
+$ErrorActionPreference = 'Stop'
+try {
+  Start-Process -FilePath ${psQuote(nodeExe)} -ArgumentList ${psQuote(argsString)} -WindowStyle Hidden
+} catch {
+  # surface failures instead of silently doing nothing
+  $log = Join-Path $env:APPDATA 'cline-kit\\launcher-error.log'
+  Set-Content -LiteralPath $log -Value ((Get-Date).ToString('o') + ' ' + $_.Exception.Message)
+}
+`;
+
+function psQuote(s) { return "'" + String(s).replace(/'/g, "''") + "'"; }
+// PowerShell does not treat backslash as an escape character, so JSON.stringify would leave
+// doubled backslashes in paths and every comparison downstream would fail. Build a real
+// PowerShell array of single-quoted literals instead.
+function psArray(items) { return "@(" + items.map(psQuote).join(",") + ")"; }
+
+function lnkSearchDirs() {
+  const appdata = process.env.APPDATA || path.join(os.homedir(), "AppData", "Roaming");
+  const progdata = process.env.ProgramData || "C:\\ProgramData";
+  return [
+    path.join(appdata, "Microsoft", "Windows", "Start Menu", "Programs"),
+    path.join(progdata, "Microsoft", "Windows", "Start Menu", "Programs"),
+    path.join(os.homedir(), "Desktop"),
+    path.join(process.env.Public || "C:\\Users\\Public", "Desktop")
+  ];
+}
+
+function findShortcuts(exePath) {
+  if (process.platform !== "win32") return [];
+  const dirs = lnkSearchDirs().filter((d) => fs.existsSync(d));
+  const script = `$exe = ${psQuote(exePath)}
+$dirs = ${psArray(dirs)}
+$sh = New-Object -ComObject WScript.Shell
+foreach ($d in $dirs) {
+  if (-not (Test-Path -LiteralPath $d)) { continue }
+  Get-ChildItem -LiteralPath $d -Filter *.lnk -Recurse -ErrorAction SilentlyContinue | ForEach-Object {
+    try {
+      $t = $sh.CreateShortcut($_.FullName).TargetPath
+      if ($t -and ($t -ieq $exe)) { Write-Output $_.FullName }
+    } catch {}
+  }
+}`;
+  try {
+    const out = execFileSync("powershell.exe", ["-NoProfile", "-Command", script], { encoding: "utf8", timeout: 60000 });
+    return out.split(/\r?\n/).map((s) => s.trim()).filter(Boolean);
+  } catch (e) { return []; }
+}
+
+function setShortcut(lnkPath, target, args, icon, workingDir, description) {
+  const script = `$sh = New-Object -ComObject WScript.Shell
+$o = $sh.CreateShortcut(${psQuote(lnkPath)})
+$o.TargetPath = ${psQuote(target)}
+$o.Arguments = ${psQuote(args || "")}
+$o.IconLocation = ${psQuote(icon || target + ",0")}
+$o.WorkingDirectory = ${psQuote(workingDir || path.dirname(target))}
+$o.Description = ${psQuote(description || "")}
+$o.Save()
+Write-Output "ok"`;
+  execFileSync("powershell.exe", ["-NoProfile", "-Command", script], { encoding: "utf8", timeout: 30000 });
+}
+
+function readShortcut(lnkPath) {
+  const script = `$sh = New-Object -ComObject WScript.Shell
+$o = $sh.CreateShortcut(${psQuote(lnkPath)})
+Write-Output ($o.TargetPath + [char]9 + $o.Arguments)`;
+  const out = execFileSync("powershell.exe", ["-NoProfile", "-Command", script], { encoding: "utf8", timeout: 30000 });
+  const line = out.split(/\r?\n/).map((s) => s.trim()).filter(Boolean)[0] || "";
+  const parts = line.split("\t");
+  return { target: parts[0] || "", args: parts[1] || "" };
+}
+
+function writeLauncherFiles(cfgObj) {
+  cfg.ensureDirs();
+  const cli = path.join(__dirname, "cli.js");
+  const ps1 = path.join(cfg.configDir(), "launch-cline-kit.ps1");
+  const vbs = path.join(cfg.configDir(), "launch-cline-kit.vbs");
+  // Windows PowerShell 5.1 reads .ps1 as ANSI unless a UTF-8 BOM is present, and wscript reads
+  // .vbs as ANSI unless it is UTF-16LE with a BOM. Without these, any non-ASCII character in the
+  // install path (a Chinese username, for example) silently breaks the launcher.
+  fs.writeFileSync(ps1, "" + PS1(process.execPath, '"' + cli + '" start'), "utf8");
+  fs.writeFileSync(vbs, "" + VBS(ps1), "utf16le");
+  return { ps1, vbs };
+}
+
+async function install(cfgObj, opts) {
+  opts = opts || {};
+  if (process.platform !== "win32") throw new Error("shortcut install is Windows-only for now");
+  const detect = require("./detect");
+  const found = detect.detect(cfgObj);
+  if (!found.path) throw new Error("cline-app.exe not found; set it with `ckit config --cline-path ...`");
+  const { vbs } = writeLauncherFiles(cfgObj);
+
+  // Re-running `install` must not lose the backup of the original shortcut targets.
+  const known = (cfgObj.originalShortcuts || []).filter((s) => s && s.lnk && fs.existsSync(s.lnk));
+  let toPoint;
+  if (known.length) {
+    toPoint = known.map((s) => s.lnk);
+  } else {
+    const existing = findShortcuts(found.path);
+    if (existing.length) {
+      cfgObj.originalShortcuts = existing.map((p) => Object.assign({ lnk: p }, readShortcut(p)));
+      toPoint = existing;
+    } else {
+      const appdata = process.env.APPDATA || path.join(os.homedir(), "AppData", "Roaming");
+      const lnk = path.join(appdata, "Microsoft", "Windows", "Start Menu", "Programs", "Cline (中文).lnk");
+      cfgObj.originalShortcuts = [];
+      toPoint = [lnk];
+    }
+  }
+
+  const touched = [];
+  for (const lnk of toPoint) {
+    setShortcut(lnk, "C:\\Windows\\System32\\wscript.exe", '"' + vbs + '"', found.path + ",0",
+      path.dirname(found.path), "Cline (Cline-kit enhanced)");
+    touched.push(lnk);
+  }
+  cfgObj.shortcutPath = touched[0];
+  cfgObj.clineExeForShortcut = found.path;
+  cfg.write(cfgObj);
+  return { exe: found.path, shortcuts: touched, launcher: vbs };
+}
+
+async function uninstall(cfgObj) {
+  const restore = [];
+  for (const s of (cfgObj.originalShortcuts || [])) {
+    try {
+      setShortcut(s.lnk, s.target, s.args, s.target + ",0", path.dirname(s.target), "");
+      restore.push(s.lnk);
+    } catch (e) { /* ignore individual failures */ }
+  }
+  // remove a shortcut we created ourselves (no original to restore)
+  if (!restore.length && cfgObj.shortcutPath && fs.existsSync(cfgObj.shortcutPath)) {
+    try { fs.unlinkSync(cfgObj.shortcutPath); restore.push("removed " + cfgObj.shortcutPath); } catch (e) { }
+  }
+  cfgObj.shortcutPath = null;
+  cfgObj.originalShortcuts = [];
+  cfg.write(cfgObj);
+  return { restored: restore };
+}
+
+module.exports = { install, uninstall, findShortcuts, writeLauncherFiles };

package/src/launcher.js

@@ -0,0 +1,123 @@
+"use strict";
+// Start Cline with a private debug port and keep the overlay attached.
+const { spawn, execFileSync } = require("child_process");
+const fs = require("fs");
+const net = require("net");
+const path = require("path");
+const cfg = require("./config");
+const cdp = require("./cdp");
+const detect = require("./detect");
+
+function freePort() {
+  return new Promise((resolve, reject) => {
+    const srv = net.createServer();
+    srv.on("error", reject);
+    srv.listen(0, "127.0.0.1", () => {
+      const p = srv.address().port;
+      srv.close(() => resolve(p));
+    });
+  });
+}
+
+function isPortAlive(port) {
+  return cdp.pageTargets(port).then((t) => t.length > 0).catch(() => false);
+}
+
+function injectorRunning() {
+  if (process.platform !== "win32") return false;
+  try {
+    const script = "$m='injector.js';" +
+      "$ps=Get-CimInstance Win32_Process -Filter \"Name='node.exe'\" | " +
+      "Where-Object { $_.CommandLine -match $m }; $ps.ProcessId -join ','";
+    const out = execFileSync("powershell.exe", ["-NoProfile", "-Command", script], { encoding: "utf8", timeout: 15000 });
+    return out.trim() || "";
+  } catch (e) { return ""; }
+}
+
+function spawnHidden(file, args, opts) {
+  const child = spawn(file, args, Object.assign({
+    detached: true,
+    stdio: "ignore",
+    windowsHide: true
+  }, opts || {}));
+  child.unref();
+  return child;
+}
+
+function clineRunning() {
+  if (process.platform !== "win32") return false;
+  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 false; }
+}
+
+function killCline() {
+  if (process.platform !== "win32") return false;
+  try {
+    execFileSync("taskkill.exe", ["/IM", "cline-app.exe", "/F"], { encoding: "utf8" });
+    return true;
+  } catch (e) { return false; }
+}
+
+async function start(opts) {
+  opts = opts || {};
+  const conf = cfg.read();
+  const found = detect.detect(conf);
+  if (!found.path) {
+    throw new Error("cline-app.exe not found. Set it with: cline-kit config --cline-path \"C:\\path\\cline-app.exe\"");
+  }
+  let port = conf.port;
+  let alive = port ? await isPortAlive(port) : false;
+
+  if (!alive && clineRunning() && !opts.restart) {
+    // Cline is already up without a debug port; a second launch would just focus the old window.
+    return { exe: found.path, source: found.source, port: null, debugPortAlive: false, needsRestart: true };
+  }
+  if (opts.restart) {
+    killCline();
+    await new Promise((r) => setTimeout(r, 2500));
+  }
+  if (!alive) {
+    port = await freePort();
+    conf.port = port;
+    conf.clinePath = found.path;
+    cfg.ensureDirs();
+    cfg.write(conf);
+    const env = Object.assign({}, process.env, {
+      WEBVIEW2_ADDITIONAL_BROWSER_ARGUMENTS: "--remote-debugging-port=" + port
+    });
+    spawnHidden(found.path, [], { env, cwd: path.dirname(found.path) });
+    for (let i = 0; i < 40 && !(alive = await isPortAlive(port)); i++) {
+      await new Promise((r) => setTimeout(r, 500));
+    }
+  }
+  // cwd must NOT be src/: a process whose working directory is inside the folder locks it,
+  // which blocks renaming the checkout or replacing files on update.
+  const repoRoot = path.join(__dirname, "..");
+  const injectorPath = path.join(__dirname, "injector.js");
+  let stale = false;
+  try {
+    const running = injectorRunning();
+    if (running) {
+      const current = require("./payload").compose(cfg.read()).version;
+      stale = require("./injector").readActiveVersion() !== current;
+    }
+  } catch (e) { stale = false; }
+  if (stale) stop();
+  if (!injectorRunning() || stale) {
+    spawnHidden(process.execPath, [injectorPath], { cwd: repoRoot });
+  }
+  return { exe: found.path, source: found.source, port, debugPortAlive: alive, restartedInjector: stale };
+}
+
+function stop() {
+  const ids = injectorRunning();
+  if (!ids) return { stopped: false };
+  for (const pid of ids.split(",").filter(Boolean)) {
+    try { execFileSync("taskkill.exe", ["/PID", pid.trim(), "/F"], { encoding: "utf8" }); } catch (e) { }
+  }
+  return { stopped: true, pids: ids };
+}
+
+module.exports = { start, stop, freePort, isPortAlive, injectorRunning, clineRunning, killCline };

package/src/payload.js

@@ -0,0 +1,80 @@
+"use strict";
+// Build the JS source injected into the Cline webview: dictionary + engine + enabled features.
+// The composite version lets the injector notice feature toggles, not just dictionary bumps.
+const fs = require("fs");
+const path = require("path");
+const crypto = require("crypto");
+const dict = require("./dict");
+const features = require("./features");
+
+const ENGINE = fs.readFileSync(path.join(__dirname, "engine.js"), "utf8");
+
+function json(x) {
+  return JSON.stringify(x).replace(/</g, "\\u003c");
+}
+
+function hash12(s) {
+  return crypto.createHash("sha1").update(s).digest("hex").slice(0, 12);
+}
+
+function compose(cfgObj) {
+  const d = dict.load(cfgObj);
+  // the engine guards on its own build hash so code edits hot-swap even when the dictionary
+  // version is unchanged
+  d.engineBuild = hash12(ENGINE);
+  const { picked } = features.resolve(cfgObj, d);
+  const parts = ["const DICT = " + json(d) + ";", ENGINE];
+
+  for (const f of picked) {
+    // per-feature build hash: the feature's own guard compares against it, so editing the script
+    // hot-swaps it without anyone remembering to bump a VER constant
+    const cfgObjForFeature = Object.assign({}, f.config, { __build: hash12(f.source) });
+    parts.push(
+      "window.__clineKitFeature = window.__clineKitFeature || {};",
+      "window.__clineKitFeature[" + json(f.id) + "] = " + json(cfgObjForFeature) + ";",
+      "try {\n" + f.source + "\n} catch (e) { try { console.error('[cline-kit] feature " + f.id + " failed:', e && e.message); } catch (_) { } }"
+    );
+  }
+
+  // Version = dictionary version + a hash of the composed source. Keying on the hash means editing
+  // engine or feature code triggers a re-inject on its own; a hand-maintained per-feature VER can be
+  // forgotten, and the symptom (stale overlay, no error) is nasty to debug.
+  const body = parts.join("\n");
+  const hash = crypto.createHash("sha1").update(body).digest("hex").slice(0, 9);
+  const version = "d" + d.version + "+" + hash;
+
+  // Everything is wrapped in one function scope. A top-level `const DICT` would throw
+  // "Identifier 'DICT' has already been declared" on the *second* Runtime.evaluate in the same
+  // document, which would silently kill every hot update after the first one.
+  return {
+    source: "(function(){\n" + body + "\n})();",
+    version,
+    dict: d,
+    picked
+  };
+}
+
+function build(cfgObj) {
+  return compose(cfgObj).source;
+}
+
+function info(cfgObj) {
+  const { version, dict: d, picked } = compose(cfgObj);
+  const enabled = features.enabledSet(cfgObj);
+  return {
+    language: d.language,
+    version,
+    dictionaryVersion: d.version,
+    clineVersion: d.clineVersion || null,
+    updated: d.updated || null,
+    entries: Object.keys(d.entries || {}).length,
+    rules: (d.rules || []).length,
+    prefixes: (d.prefixes || []).length,
+    sources: d.sourceVersions,
+    features: features.list().map((f) => ({
+      id: f.id, title: f.title, version: f.version, enabled: !!enabled[f.id]
+    }))
+  };
+}
+
+module.exports = { build, info, compose };