coc-vscode-loader 1.1.1 → 1.1.4

package/lib/index.js

@@ -5,6 +5,13 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  try {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  } catch (e) {
+    throw mod = 0, e;
+  }
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -27,21 +34,105 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// package.json
+var require_package = __commonJS({
+  "package.json"(exports2, module2) {
+    module2.exports = {
+      name: "coc-vscode-loader",
+      version: "1.1.4",
+      description: "Run VS Code extensions seamlessly in coc.nvim",
+      main: "lib/index.js",
+      keywords: [
+        "coc.nvim",
+        "vscode",
+        "neovim",
+        "lsp",
+        "plugin-loader",
+        "vim"
+      ],
+      repository: {
+        type: "git",
+        url: "git+https://github.com/coc-plugin/coc-vscode-loader.git"
+      },
+      bugs: {
+        url: "https://github.com/coc-plugin/coc-vscode-loader/issues"
+      },
+      homepage: "https://www.npmjs.com/package/coc-vscode-loader",
+      files: [
+        "lib/",
+        "converter/src/",
+        "converter/package.json",
+        "assets/"
+      ],
+      license: "MIT",
+      engines: {
+        coc: ">= 0.0.80"
+      },
+      scripts: {
+        "bundle-converter": "rm -rf converter && cp -r ../converter ./converter && cd converter && npm install --legacy-peer-deps",
+        build: "npm run bundle-converter && node esbuild.mjs",
+        prepare: "node esbuild.mjs"
+      },
+      devDependencies: {
+        "coc.nvim": "^0.0.83-next.18",
+        esbuild: "^0.28.1",
+        typescript: "^6.0.3"
+      },
+      activationEvents: [
+        "onCommand:loader.open",
+        "onCommand:loader.install",
+        "onCommand:loader.uninstall",
+        "onCommand:loader.update",
+        "onCommand:loader.uninstallAll",
+        "onCommand:loader.updateRegistry",
+        "onCommand:loader._dispatch"
+      ],
+      contributes: {
+        commands: [
+          { command: "loader.open", title: "Open VS Code extension loader" },
+          { command: "loader.install", title: "Install a VS Code extension" },
+          { command: "loader.uninstall", title: "Uninstall a package" },
+          { command: "loader.update", title: "Update a package" },
+          { command: "loader.uninstallAll", title: "Uninstall all packages" },
+          { command: "loader.updateRegistry", title: "Update package registry" },
+          { command: "loader._dispatch", title: "" }
+        ]
+      }
+    };
+  }
+});
+
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
   activate: () => activate
 });
 module.exports = __toCommonJS(index_exports);
-var import_coc2 = require("coc.nvim");
+var import_coc3 = require("coc.nvim");
 
 // src/registry.ts
 var path = __toESM(require("path"));
 var fs = __toESM(require("fs"));
 var os = __toESM(require("os"));
+function pluginVersion() {
+  try {
+    return require_package().version;
+  } catch {
+    return "0.0.0";
+  }
+}
 var REMOTE_REGISTRY_URL = "https://raw.githubusercontent.com/coc-plugin/coc-vscode-registry/main/registry.json";
 var CACHE_PATH = path.join(os.homedir(), ".config", "coc", "converter-cache", "registry.json");
 var cached = null;
+function getLocalRegistryPath() {
+  try {
+    const pluginDir2 = path.dirname(fs.realpathSync(__dirname));
+    const local = path.join(pluginDir2, "..", "coc-vscode-registry", "registry.json");
+    if (fs.existsSync(local)) return local;
+  } catch {
+  }
+  return null;
+}
 function loadCache() {
   try {
     if (fs.existsSync(CACHE_PATH)) {
@@ -52,6 +143,16 @@ function loadCache() {
   return null;
 }
 async function updateRegistry() {
+  const localPath = process.env.COC_REGISTRY_PATH || getLocalRegistryPath();
+  if (localPath) {
+    if (!fs.existsSync(localPath)) throw new Error(`Local registry not found: ${localPath}`);
+    const data2 = JSON.parse(fs.readFileSync(localPath, "utf-8"));
+    if (!Array.isArray(data2)) throw new Error("Invalid registry format");
+    fs.mkdirSync(path.dirname(CACHE_PATH), { recursive: true });
+    fs.writeFileSync(CACHE_PATH, JSON.stringify(data2, null, 2));
+    cached = data2;
+    return data2.length;
+  }
   const res = await fetch(REMOTE_REGISTRY_URL);
   if (!res.ok) throw new Error(`HTTP ${res.status}`);
   const data = await res.json();
@@ -61,10 +162,21 @@ async function updateRegistry() {
   cached = data;
   return data.length;
 }
+function satisfiesVersion(required) {
+  const a = pluginVersion().replace(/-.*$/, "").split(".").map(Number);
+  const b = required.replace(/-.*$/, "").split(".").map(Number);
+  for (let i = 0; i < Math.max(a.length, b.length); i++) {
+    const va = a[i] || 0, vb = b[i] || 0;
+    if (va > vb) return true;
+    if (va < vb) return false;
+  }
+  return true;
+}
 function getAllPackages() {
-  if (cached) return cached;
-  cached = loadCache();
-  return cached || [];
+  if (!cached) {
+    cached = loadCache() || [];
+  }
+  return cached.filter((p) => !p.minPluginVersion || satisfiesVersion(p.minPluginVersion));
 }
 function getPackage(name) {
   return getAllPackages().find((p) => p.name === name);
@@ -102,10 +214,11 @@ function createInitialState() {
       commitDate,
       progressLog: [],
       expanded: false,
-      logExpanded: false
+      logExpanded: false,
+      marked: false
     };
   });
-  return { packages, searchQuery: "", showHelp: false, activePill: null, dirty: false, viewFilter: "all" };
+  return { packages, searchQuery: "", showHelp: false, activePill: null, dirty: false, viewFilter: "all", sortBy: "default" };
 }
 var StateManager = class {
   constructor(initial) {
@@ -144,8 +257,11 @@ var StateManager = class {
         }
         pkg.status = status;
         if (extra?.progress !== void 0) pkg.progress = extra.progress;
-        if (extra?.logEntry !== void 0) pkg.progressLog.push(extra.logEntry);
-        if (extra?.appendLog && extra?.progress !== void 0) pkg.progressLog.push(extra.progress);
+        if (extra?.logEntry !== void 0) {
+          pkg.progressLog.push(extra.logEntry);
+        } else if (extra?.progress !== void 0) {
+          pkg.progressLog.push(extra.progress);
+        }
         if (extra?.error !== void 0) pkg.error = extra.error;
         if (status === "installed" || status === "not-installed") {
           pkg.progress = void 0;
@@ -175,6 +291,21 @@ var StateManager = class {
       s.viewFilter = filter;
     });
   }
+  cycleViewFilter() {
+    this.mutate((s) => {
+      s.viewFilter = s.viewFilter === "all" ? "installed" : s.viewFilter === "installed" ? "not-installed" : "all";
+    });
+  }
+  setSortBy(sortBy) {
+    this.mutate((s) => {
+      s.sortBy = sortBy;
+    });
+  }
+  cycleSortBy() {
+    this.mutate((s) => {
+      s.sortBy = s.sortBy === "default" ? "name" : s.sortBy === "name" ? "status" : s.sortBy === "status" ? "type" : "default";
+    });
+  }
   setStatusMessage(msg) {
     this.mutate((s) => {
       s.statusMessage = msg;
@@ -203,14 +334,39 @@ var StateManager = class {
       pkgs = pkgs.filter((p) => p.status === "installed");
     }
     const q = this.state.searchQuery.toLowerCase();
-    if (!q) return pkgs;
-    return pkgs.filter(
-      (p) => p.info.name.toLowerCase().includes(q) || p.info.displayName.toLowerCase().includes(q) || p.info.description.toLowerCase().includes(q)
-    );
+    if (q) {
+      pkgs = pkgs.filter(
+        (p) => p.info.name.toLowerCase().includes(q) || p.info.displayName.toLowerCase().includes(q) || p.info.description.toLowerCase().includes(q)
+      );
+    }
+    const sortBy = this.state.sortBy;
+    if (sortBy === "name") {
+      pkgs = [...pkgs].sort((a, b) => a.info.name.localeCompare(b.info.name));
+    } else if (sortBy === "status") {
+      const order = { installed: 0, installing: 1, updating: 2, uninstalling: 3, failed: 4, "not-installed": 5 };
+      pkgs = [...pkgs].sort((a, b) => (order[a.status] ?? 9) - (order[b.status] ?? 9));
+    } else if (sortBy === "type") {
+      pkgs = [...pkgs].sort((a, b) => a.info.type.localeCompare(b.info.type));
+    }
+    return pkgs;
   }
   getPackage(name) {
     return this.state.packages.find((p) => p.info.name === name);
   }
+  toggleMark(name) {
+    this.mutate((s) => {
+      const pkg = s.packages.find((p) => p.info.name === name);
+      if (pkg) pkg.marked = !pkg.marked;
+    });
+  }
+  clearMarks() {
+    this.mutate((s) => {
+      for (const p of s.packages) p.marked = false;
+    });
+  }
+  getMarkedNames() {
+    return this.state.packages.filter((p) => p.marked).map((p) => p.info.name);
+  }
   refreshPackages() {
     this.mutate((s) => {
       const updated = getAllPackages();
@@ -226,7 +382,8 @@ var StateManager = class {
           status: isInstalled(info.name) ? "installed" : "not-installed",
           progressLog: [],
           expanded: false,
-          logExpanded: false
+          logExpanded: false,
+          marked: false
         };
       });
     });
@@ -234,10 +391,11 @@ var StateManager = class {
 };
 
 // src/tui.ts
-var import_coc = require("coc.nvim");
+var import_coc2 = require("coc.nvim");
 
 // src/pipeline.ts
 var import_child_process = require("child_process");
+var import_coc = require("coc.nvim");
 var path3 = __toESM(require("path"));
 var fs3 = __toESM(require("fs"));
 var os3 = __toESM(require("os"));
@@ -256,12 +414,9 @@ function pluginDir(name) {
 }
 function converterCliPath() {
   const base = path3.resolve(__dirname, "..");
-  const cwd = process.cwd();
   const candidates = [
     path3.join(base, "converter", "src", "cli.ts"),
-    path3.join(base, "..", "converter", "src", "cli.ts"),
-    path3.join(cwd, "converter", "src", "cli.ts"),
-    path3.join(cwd, "..", "converter", "src", "cli.ts")
+    path3.join(base, "..", "converter", "src", "cli.ts")
   ];
   for (const p of candidates) {
     if (fs3.existsSync(p)) return p;
@@ -270,37 +425,48 @@ function converterCliPath() {
     "converter CLI not found. Please set $COC_CONVERTER_PATH to the converter/ directory, or ensure it is at the same level as coc-converter/"
   );
 }
+var CMD_TIMEOUT = 3e5;
 async function run(cmd, args, cwd, onLine) {
   return new Promise((resolve2, reject) => {
     const child = (0, import_child_process.spawn)(cmd, args, { cwd, stdio: ["ignore", "pipe", "pipe"], shell: true });
-    const lines = [];
+    const timer = setTimeout(() => {
+      child.kill("SIGTERM");
+      reject(new Error(`Timed out after ${CMD_TIMEOUT / 1e3}s: ${cmd} ${args.join(" ")}`));
+    }, CMD_TIMEOUT);
     const handler = (data) => {
       const text = data.toString();
-      lines.push(text);
-      onLine(text);
+      onLine?.(text);
     };
     child.stdout.on("data", handler);
     child.stderr.on("data", handler);
+    let stderrBuf = "";
+    child.stderr.on("data", (d) => {
+      stderrBuf += d.toString();
+    });
     child.on("close", (code) => {
+      clearTimeout(timer);
       if (code === 0) resolve2();
-      else reject(new Error(`${cmd} ${args.join(" ")} exited with code ${code}`));
+      else reject(new Error(`${cmd} ${args.join(" ")} exited with code ${code}
+${stderrBuf.trim()}`));
+    });
+    child.on("error", (e) => {
+      clearTimeout(timer);
+      reject(e);
     });
-    child.on("error", reject);
   });
 }
 async function downloadSource(info, name, onProgress) {
   const srcDir = sourceDir(name);
   const cache = cacheDir(name);
   const repoUrl = `https://github.com/${info.source.repo}.git`;
+  const log = (chunk) => onProgress(1, 5, chunk.trim(), "");
   if (fs3.existsSync(srcDir)) {
     onProgress(1, 5, "Updating source...", `git -C ${srcDir} pull`);
-    await run("git", ["-C", srcDir, "pull"], cache, () => {
-    });
+    await run("git", ["-C", srcDir, "pull"], cache, log);
   } else {
     onProgress(1, 5, "Cloning repository...", `git clone --depth=1 ${repoUrl}`);
     fs3.mkdirSync(cache, { recursive: true });
-    await run("git", ["clone", "--depth=1", repoUrl, srcDir], cache, () => {
-    });
+    await run("git", ["clone", "--depth=1", repoUrl, srcDir], cache, log);
   }
   return info.source.subdir ? path3.join(srcDir, info.source.subdir) : srcDir;
 }
@@ -309,51 +475,165 @@ async function convertSource(inputDir, name, onProgress) {
   if (fs3.existsSync(build)) fs3.rmSync(build, { recursive: true });
   const cli = converterCliPath();
   onProgress(2, 5, "Converting...", `converter convert ${inputDir} -o ${build}`);
-  await run("npx", ["tsx", cli, "convert", inputDir, "-o", build], cacheDir(name), () => {
-  });
+  const log = (chunk) => onProgress(2, 5, chunk.trim(), "");
+  await run("npx", ["tsx", cli, "convert", inputDir, "-o", build], cacheDir(name), log);
 }
 async function buildPackage(name, inputDir, info, onProgress) {
   const build = buildDir(name);
+  const npmLog = (chunk) => onProgress(3, 5, chunk.trim(), "");
   onProgress(3, 5, "Installing dependencies...", "npm install --legacy-peer-deps");
-  await run("npm", ["install", "--legacy-peer-deps"], build, () => {
-  });
+  await run("npm", ["install", "--legacy-peer-deps"], build, npmLog);
   onProgress(3, 5, "Running postinstall...", "npm run postinstall");
-  await run("npm", ["run", "postinstall", "--if-present"], build, () => {
-  }).catch(() => {
+  await run("npm", ["run", "postinstall", "--if-present"], build, npmLog).catch(() => {
   });
+  if (info.pipPackages?.length) {
+    const pipLog = (chunk) => onProgress(3, 5, chunk.trim(), "");
+    const pythonPaths = [
+      "/opt/homebrew/bin/python3",
+      "/usr/local/bin/python3",
+      "/usr/bin/python3",
+      "python3"
+    ];
+    let pythonBin = "";
+    for (const p of pythonPaths) {
+      if (p === "python3") {
+        try {
+          await run("python3", ["--version"], build);
+          pythonBin = "python3";
+          break;
+        } catch {
+          continue;
+        }
+      } else if (fs3.existsSync(p)) {
+        pythonBin = p;
+        break;
+      }
+    }
+    if (!pythonBin) throw new Error("python3 not found, cannot install pip packages: " + info.pipPackages.join(", "));
+    const pipArgs = ["-m", "pip", "install"];
+    if (process.platform === "linux" || process.platform === "darwin") {
+      try {
+        const verOut = await runWithOutput(pythonBin, ["--version"], build);
+        const m = verOut.match(/^Python\s+(\d+)\.(\d+)/);
+        if (m) {
+          const pyMajor = parseInt(m[1]), pyMinor = parseInt(m[2]);
+          if (pyMajor > 3 || pyMajor === 3 && pyMinor >= 11) pipArgs.push("--break-system-packages");
+        }
+      } catch {
+      }
+    }
+    onProgress(3, 5, "Installing pip packages...", `${pythonBin} -m pip install ${info.pipPackages.join(" ")}`);
+    await run(pythonBin, pipArgs.concat(...info.pipPackages), build, pipLog);
+  }
   const serverDir = path3.join(inputDir, "server");
   if (fs3.existsSync(serverDir) && fs3.existsSync(path3.join(serverDir, "package.json"))) {
     onProgress(3, 5, "Installing server dependencies...", `npm install in ${serverDir}`);
-    await run("npm", ["install", "--legacy-peer-deps"], serverDir, () => {
-    });
+    await run("npm", ["install", "--legacy-peer-deps"], serverDir, npmLog);
     const destServer = path3.join(build, "server");
     if (fs3.existsSync(destServer)) fs3.rmSync(destServer, { recursive: true });
     fs3.cpSync(serverDir, destServer, { recursive: true });
   }
   onProgress(4, 5, "Building...", "node esbuild.mjs");
-  await run("node", ["esbuild.mjs"], build, () => {
-  });
+  const buildLog = (chunk) => onProgress(4, 5, chunk.trim(), "");
+  await run("node", ["esbuild.mjs"], build, buildLog);
   if (info.serverBinary) {
     const sb = info.serverBinary;
     onProgress(4, 5, "Downloading language server...", `fetching ${sb.repo}`);
     try {
-      const tagData = await runWithOutput("gh", ["api", `repos/${sb.repo}/releases/latest`, "--jq", ".tag_name"], os3.homedir());
-      const version = tagData.replace(/^v/, "");
+      const tagRes = await fetch(`https://api.github.com/repos/${sb.repo}/releases/latest`);
+      if (!tagRes.ok) throw new Error(`GitHub API: HTTP ${tagRes.status}`);
+      const tagData = await tagRes.json();
+      const tag = tagData.tag_name;
+      const version = tag.replace(/^v/, "");
+      const archMap = {
+        arm64: "aarch64",
+        x64: "x86_64"
+      };
+      const platformMap = {
+        darwin: "apple-darwin",
+        linux: "unknown-linux-gnu",
+        win32: "pc-windows-msvc"
+      };
       const arch2 = os3.arch() === "arm64" ? "arm64" : "x64";
       const platform = process.platform === "win32" ? "win32" : process.platform === "darwin" ? "darwin" : "linux";
-      const filename = sb.asset.replace("{{version}}", version).replace("{{platform}}", platform).replace("{{arch}}", arch2);
-      const url = `https://github.com/${sb.repo}/releases/download/${version}/${filename}`;
+      const rawArch = archMap[arch2] || arch2;
+      const rustTarget = `${rawArch}-${platformMap[platform] || platform}`;
+      const filename = sb.asset.replace(/\{\{version}}/g, version).replace(/\{\{platform}}/g, platform).replace(/\{\{arch}}/g, arch2).replace(/\{\{raw-arch}}/g, rawArch).replace(/\{\{rust-target}}/g, rustTarget);
+      const url = `https://github.com/${sb.repo}/releases/download/${tag}/${filename}`;
       onProgress(4, 5, "Downloading...", `curl ${filename}`);
-      await run("curl", ["-sSL", url, "-o", path3.join(build, filename)], build, () => {
-      });
-      onProgress(4, 5, "Extracting...", `tar xzf ${filename}`);
+      await run("curl", ["-#SL", url, "-o", path3.join(build, filename)], build);
+      onProgress(4, 5, "Extracting...", filename);
       const serverDir2 = path3.join(build, "server");
       fs3.mkdirSync(serverDir2, { recursive: true });
-      await run("tar", ["xzf", filename, "-C", serverDir2], build, () => {
-      });
-      fs3.rmSync(path3.join(build, filename));
+      if (filename.endsWith(".zip")) {
+        await run("unzip", ["-o", filename, "-d", serverDir2], build);
+      } else if (filename.endsWith(".gz") && !filename.endsWith(".tar.gz")) {
+        const outName = filename.replace(/\.gz$/, "");
+        await run("gunzip", [filename], build);
+        fs3.renameSync(path3.join(build, outName), path3.join(serverDir2, outName));
+      } else {
+        await run("tar", ["xzf", filename, "-C", serverDir2], build);
+      }
+      try {
+        fs3.readdirSync(serverDir2).forEach((f) => {
+          fs3.chmodSync(path3.join(serverDir2, f), 493);
+        });
+      } catch {
+      }
+      if (sb.binaryPath || filename.match(/\.(zip|gz)$/)) {
+        const archivePath = path3.join(build, filename);
+        if (fs3.existsSync(archivePath)) fs3.rmSync(archivePath);
+      }
+      const indexPath = path3.join(build, "lib", "index.js");
+      if (fs3.existsSync(indexPath)) {
+        const binPath = (sb.binaryPath || sb.asset.split(/-?\{\{/)[0]).replace(/\{\{version}}/g, version).replace(/\{\{platform}}/g, platform).replace(/\{\{arch}}/g, arch2).replace(/\{\{raw-arch}}/g, rawArch).replace(/\{\{rust-target}}/g, rustTarget);
+        let code = fs3.readFileSync(indexPath, "utf-8");
+        const svrArgs = sb.args?.length ? JSON.stringify(sb.args) : "[]";
+        code = code.replace(
+          /\{ module:\s*serverModule,\s*transport:\s*\w+\.TransportKind\.\w+\s*\}/,
+          `{ command: serverModule, args: ${svrArgs} }`
+        );
+        const serverPath = `require('path').join(__dirname, '..', 'server', '${binPath}')`;
+        code = code.replace(
+          /try\s*\{[^}]*?require\.resolve\([^)]+\)\s*;?\s*\}\s*catch\s*\{\s*\}/g,
+          `try { serverModule = ${serverPath} } catch {}`
+        );
+        code = code.replace(
+          /let\s+serverModule\s*=\s*config\.get\([^)]+\)\s*;?\s*/g,
+          `let serverModule = ${serverPath};`
+        );
+        fs3.writeFileSync(indexPath, code);
+      }
+    } catch (e) {
+      onProgress(4, 5, `Warning: serverBinary setup failed (${e.message})`, "install server binary manually");
+    }
+  }
+  const docSelPath = path3.join(build, "lib", "index.js");
+  if (fs3.existsSync(docSelPath)) {
+    let code = fs3.readFileSync(docSelPath, "utf-8");
+    const langSelector = info.languages.map((l) => `{ scheme: "file", language: "${l}" }`).join(", ");
+    code = code.replace(
+      /documentSelector:\s*\[\s*\{[^}]*?language:\s*['"][^'"]*['"][^}]*\}\s*\]/,
+      `documentSelector: [${langSelector}]`
+    );
+    code = code.replace(
+      /client\.start\(\);/g,
+      "client.start().catch(() => {/* init may complete async */});"
+    );
+    fs3.writeFileSync(docSelPath, code);
+  }
+  const pkgPath = path3.join(build, "package.json");
+  if (fs3.existsSync(pkgPath)) {
+    try {
+      const pkg = JSON.parse(fs3.readFileSync(pkgPath, "utf-8"));
+      const events = pkg.activationEvents || [];
+      const langEvents = info.languages.map((l) => `onLanguage:${l}`);
+      const newEvents = events.filter((e) => !e.startsWith("onLanguage:")).concat(langEvents);
+      if (newEvents.length > 0 && JSON.stringify(newEvents) !== JSON.stringify(events)) {
+        pkg.activationEvents = newEvents;
+        fs3.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2));
+      }
     } catch {
-      onProgress(4, 5, "Warning: server download failed", "install server binary manually");
     }
   }
 }
@@ -369,6 +649,7 @@ async function installToCoc(name, onProgress) {
   fs3.cpSync(src, dest, { recursive: true });
   const pkgPath = extensionsPkgPath();
   const pkg = JSON.parse(fs3.readFileSync(pkgPath, "utf-8"));
+  pkg.dependencies = pkg.dependencies || {};
   const depName = `coc-${name}`;
   if (!pkg.dependencies[depName]) {
     pkg.dependencies[depName] = `file:${dest}`;
@@ -379,10 +660,10 @@ async function installToCoc(name, onProgress) {
 function metaPath(name) {
   return path3.join(cacheDir(name), "meta.json");
 }
-function saveMeta(name) {
+async function saveMeta(name) {
   const srcDir = sourceDir(name);
   try {
-    const log = (0, import_child_process.execSync)(`git -C "${srcDir}" log -1 --format="%h|%s|%ar"`, { encoding: "utf-8" }).toString().trim();
+    const log = await runWithOutput("git", ["-C", srcDir, "log", "-1", "--format=%h|%s|%ar"], srcDir);
     const [commit, msg, date] = log.split("|");
     fs3.writeFileSync(metaPath(name), JSON.stringify({ commit, msg, date, updatedAt: Date.now() }, null, 2));
   } catch {
@@ -408,9 +689,10 @@ async function installPackage(state, name) {
     await convertSource(input, name, prog);
     await buildPackage(name, input, info, prog);
     await installToCoc(name, prog);
-    saveMeta(name);
+    await saveMeta(name);
     state.setDirty();
     state.setPackageStatus(name, "installed");
+    import_coc.window.showInformationMessage(`coc-${name} installed`);
     try {
       const meta = JSON.parse(fs3.readFileSync(metaPath(name), "utf-8"));
       if (meta.commit) {
@@ -440,6 +722,7 @@ async function uninstallPackage(state, name) {
     state.setPackageStatus(name, "uninstalling", { progress: "[2/3] Removing from package.json..." });
     const pkgPath = extensionsPkgPath();
     const pkg = JSON.parse(fs3.readFileSync(pkgPath, "utf-8"));
+    pkg.dependencies = pkg.dependencies || {};
     const depName = `coc-${name}`;
     if (pkg.dependencies[depName]) {
       delete pkg.dependencies[depName];
@@ -453,6 +736,7 @@ async function uninstallPackage(state, name) {
     }
     state.setPackageStatus(name, "not-installed");
     state.setDirty();
+    import_coc.window.showInformationMessage(`coc-${name} uninstalled`);
   } catch (e) {
     state.setPackageStatus(name, "failed", { error: e.message });
   }
@@ -477,9 +761,10 @@ async function updatePackage(state, name) {
     await convertSource(input, name, prog);
     await buildPackage(name, input, info, prog);
     await installToCoc(name, prog);
-    saveMeta(name);
+    await saveMeta(name);
     state.setDirty();
     state.setPackageStatus(name, "installed");
+    import_coc.window.showInformationMessage(`coc-${name} installed`);
     try {
       const meta = JSON.parse(fs3.readFileSync(metaPath(name), "utf-8"));
       if (meta.commit) {
@@ -502,6 +787,10 @@ async function updatePackage(state, name) {
 async function runWithOutput(cmd, args, cwd) {
   return new Promise((resolve2, reject) => {
     const child = (0, import_child_process.spawn)(cmd, args, { cwd, stdio: ["ignore", "pipe", "pipe"], shell: true });
+    const timer = setTimeout(() => {
+      child.kill("SIGTERM");
+      reject(new Error(`Timed out after ${CMD_TIMEOUT / 1e3}s: ${cmd} ${args.join(" ")}`));
+    }, CMD_TIMEOUT);
     let out = "";
     child.stdout.on("data", (d) => {
       out += d.toString();
@@ -509,10 +798,27 @@ async function runWithOutput(cmd, args, cwd) {
     child.stderr.on("data", (d) => {
       out += d.toString();
     });
-    child.on("close", (code) => code === 0 ? resolve2(out.trim()) : reject(new Error(`exit ${code}`)));
-    child.on("error", reject);
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      code === 0 ? resolve2(out.trim()) : reject(new Error(`exit ${code}`));
+    });
+    child.on("error", (e) => {
+      clearTimeout(timer);
+      reject(e);
+    });
   });
 }
+async function runConcurrent(items, fn, concurrency = 3) {
+  const pool = /* @__PURE__ */ new Set();
+  for (const item of items) {
+    const p = fn(item).finally(() => pool.delete(p));
+    pool.add(p);
+    if (pool.size >= concurrency) {
+      await Promise.race(pool);
+    }
+  }
+  await Promise.all(pool);
+}
 async function checkUpdates(state) {
   const s = state.getState();
   const results = {};
@@ -612,8 +918,16 @@ var LineBuffer = class {
 };
 
 // src/tui.ts
+var VERSION = (() => {
+  try {
+    const pkg = JSON.parse(require("fs").readFileSync(require("path").join(__dirname, "..", "package.json"), "utf-8"));
+    return pkg.version;
+  } catch {
+    return "0.0.0";
+  }
+})();
 var HELP_TEXT = [
-  "  coc-loader \u2014 VS Code extension \u2192 coc.nvim plugin converter",
+  `  coc-loader v${VERSION} \u2014 VS Code extension \u2192 coc.nvim plugin converter`,
   "",
   "  Keymaps:",
   "    i          Install package under cursor",
@@ -621,10 +935,18 @@ var HELP_TEXT = [
   "    U          Update all installed packages",
   "    C          Check for updates from remote",
   "    X          Uninstall package under cursor",
+  "    R          Reinstall package under cursor",
   "    Z          Uninstall all installed packages (with confirm)",
+  "    D          Clean up orphaned packages",
+  "    x          Toggle mark",
+  "    f          Cycle filter: all \u2192 installed \u2192 not-installed",
+  "    s          Cycle sort: default \u2192 name \u2192 status \u2192 type",
+  "    gg         Jump to first package",
+  "    G          Jump to last package",
   "    <Enter>    Toggle expand/collapse details",
   "    /          Search filter",
-  "    q / <Esc>  Close window",
+  "    q          Close window",
+  "    <Esc>      Help\u2192Search\u2192Marks\u2192Busy guard\u2192Close",
   "",
   "  " + "\u2500".repeat(40),
   "",
@@ -652,13 +974,21 @@ var TUI = class {
       i: "i",
       u: "u",
       X: "X",
-      cr: "<CR>"
+      R: "R",
+      cr: "<CR>",
+      f: "f",
+      s: "s",
+      x: "x",
+      D: "D",
+      gg: "gg",
+      G: "G"
     };
     this.rendering = false;
+    this.pendingRender = false;
     this.state = state;
   }
   async open() {
-    const nvim = import_coc.workspace.nvim;
+    const nvim = import_coc2.workspace.nvim;
     this.ns = await nvim.createNamespace("coc-loader");
     await nvim.command("highlight default link CocConverterTitle Title");
     await nvim.command("highlight default link CocConverterPill Visual");
@@ -700,10 +1030,11 @@ var TUI = class {
     await nvim.call("nvim_win_set_option", [this.winid, "spell", false]);
     await nvim.call("nvim_win_set_option", [this.winid, "foldenable", false]);
     this.unsubscribe = this.state.subscribe(() => {
-      this.render();
+      this.render().catch(() => {
+      });
     });
     this.disposables.push(
-      import_coc.workspace.registerAutocmd({
+      import_coc2.workspace.registerAutocmd({
         event: "WinEnter",
         request: true,
         callback: async () => {
@@ -727,10 +1058,14 @@ var TUI = class {
       `);
     }
     await this.setupKeymaps();
+    updateRegistry().then(() => this.state.refreshPackages()).catch(() => {
+      this.state.setStatusMessage("Failed to fetch remote registry (offline?)");
+      setTimeout(() => this.state.setStatusMessage(), 5e3);
+    });
     await this.render();
   }
   async getCursorLine0() {
-    const nvim = import_coc.workspace.nvim;
+    const nvim = import_coc2.workspace.nvim;
     const cursor = await nvim.call("nvim_win_get_cursor", [this.winid]);
     return cursor[0] - 1;
   }
@@ -760,6 +1095,16 @@ var TUI = class {
         this.state.setSearchQuery("");
         return;
       }
+      const hasMarks = s.packages.some((p) => p.marked);
+      if (hasMarks) {
+        this.state.clearMarks();
+        return;
+      }
+      const busy = s.packages.some((p) => ["installing", "updating", "uninstalling"].includes(p.status));
+      if (busy) {
+        import_coc2.window.showInformationMessage("Operation in progress, wait for it to finish");
+        return;
+      }
       this.close();
       return;
     }
@@ -769,26 +1114,62 @@ var TUI = class {
     }
     if (id === "slash") {
       try {
-        const q = await import_coc.workspace.nvim.call("input", ["Search: ", ""]);
+        const q = await import_coc2.workspace.nvim.call("input", ["Search: ", ""]);
         if (q) this.state.setSearchQuery(q);
       } catch {
       }
       return;
     }
+    if (id === "f") {
+      this.state.cycleViewFilter();
+      return;
+    }
+    if (id === "s") {
+      this.state.cycleSortBy();
+      return;
+    }
+    if (id === "gg") {
+      const firstLine = Math.min(...this.pkgLineMap.keys());
+      if (isFinite(firstLine)) {
+        await import_coc2.workspace.nvim.call("nvim_win_set_cursor", [this.winid, [firstLine + 1, 0]]);
+      }
+      return;
+    }
+    if (id === "G") {
+      const lastLine = Math.max(...this.pkgLineMap.keys());
+      if (isFinite(lastLine)) {
+        await import_coc2.workspace.nvim.call("nvim_win_set_cursor", [this.winid, [lastLine + 1, 0]]);
+      }
+      return;
+    }
+    if (id === "D") {
+      const installed = s.packages.filter((p) => p.status === "installed");
+      const removed = installed.filter((p) => !getPackage(p.info.name));
+      if (removed.length === 0) {
+        import_coc2.window.showInformationMessage("No orphaned packages found");
+        return;
+      }
+      const ok = await import_coc2.window.showPrompt(`Uninstall ${removed.length} orphaned package(s)?`);
+      if (ok) {
+        for (const p of removed) await uninstallPackage(this.state, p.info.name);
+      }
+      return;
+    }
     if (id === "U") {
       const installed = s.packages.filter((p) => p.status === "installed");
       if (installed.length === 0) return;
       this.state.setActivePill("U");
-      await Promise.all(installed.map((p) => updatePackage(this.state, p.info.name)));
+      const names = installed.map((p) => p.info.name);
+      await runConcurrent(names, (name) => updatePackage(this.state, name));
       this.state.setActivePill(null);
       return;
     }
     if (id === "Z") {
       const installed = s.packages.filter((p) => p.status === "installed");
       if (installed.length === 0) return;
-      const ok = await import_coc.window.showPrompt(`Uninstall all ${installed.length} packages?`);
+      const ok = await import_coc2.window.showPrompt(`Uninstall all ${installed.length} packages?`);
       if (ok) {
-        for (const pkg of installed) uninstallPackage(this.state, pkg.info.name);
+        for (const pkg of installed) await uninstallPackage(this.state, pkg.info.name);
       }
       return;
     }
@@ -802,6 +1183,10 @@ var TUI = class {
     if (!pkgName) return;
     const entry = this.state.getPackage(pkgName);
     if (!entry) return;
+    if (id === "x") {
+      this.state.toggleMark(pkgName);
+      return;
+    }
     if (id === "i" && entry.status === "not-installed") {
       await installPackage(this.state, pkgName);
       return;
@@ -814,6 +1199,11 @@ var TUI = class {
       uninstallPackage(this.state, pkgName);
       return;
     }
+    if (id === "R" && entry.status === "installed") {
+      await uninstallPackage(this.state, pkgName);
+      await installPackage(this.state, pkgName);
+      return;
+    }
     if (id === "cr") {
       if (this.logLineSet.has(line0)) {
         this.state.toggleLog(pkgName);
@@ -824,7 +1214,7 @@ var TUI = class {
     }
   }
   async setupKeymaps() {
-    const buf = import_coc.workspace.nvim.createBuffer(this.bufnr);
+    const buf = import_coc2.workspace.nvim.createBuffer(this.bufnr);
     const entries = [
       ["q", "q"],
       ["<Esc>", "esc"],
@@ -838,7 +1228,13 @@ var TUI = class {
       ["H", "H"],
       ["u", "u"],
       ["X", "X"],
-      ["x", "X"],
+      ["R", "R"],
+      ["f", "f"],
+      ["s", "s"],
+      ["x", "x"],
+      ["D", "D"],
+      ["gg", "gg"],
+      ["G", "G"],
       ["<CR>", "cr"]
     ];
     for (const [vimKey, id] of entries) {
@@ -857,20 +1253,25 @@ var TUI = class {
     this.disposables = [];
     if (this.winid) {
       try {
-        await import_coc.workspace.nvim.call("nvim_win_close", [this.winid, true]);
+        await import_coc2.workspace.nvim.call("nvim_win_close", [this.winid, true]);
       } catch {
       }
       this.winid = 0;
     }
     if (needRestart) {
-      import_coc.workspace.nvim.command("CocRestart", true);
+      import_coc2.workspace.nvim.command("CocRestart", true);
     }
   }
   async render() {
-    if (!this.winid || this.rendering) return;
+    if (!this.winid) return;
+    if (this.rendering) {
+      this.pendingRender = true;
+      return;
+    }
     this.rendering = true;
+    this.pendingRender = false;
     try {
-      const nvim = import_coc.workspace.nvim;
+      const nvim = import_coc2.workspace.nvim;
       const state = this.state.getState();
       const filtered = this.state.getFilteredPackages();
       const result = state.showHelp ? this.renderHelp() : this.renderPackageList(state, filtered);
@@ -891,12 +1292,13 @@ var TUI = class {
       this.logLineSet = result.logLines;
     } finally {
       this.rendering = false;
+      if (this.pendingRender) this.render();
     }
   }
   renderHelp() {
     const header = [
       "",
-      "  coc-loader v0.1",
+      `  coc-loader v${VERSION}`,
       "  press ? help | / search | q quit",
       "  " + "\u2500".repeat(50),
       ""
@@ -938,7 +1340,13 @@ var TUI = class {
     buf.highlight(/\([IU?C]\)/g, "CocConverterKey");
     buf.nl();
     buf.nl();
+    const filterLabel = state.viewFilter === "all" ? "All" : state.viewFilter === "installed" ? "Installed" : "Available";
+    const sortLabel = state.sortBy === "default" ? "Default" : state.sortBy === "name" ? "Name" : state.sortBy === "status" ? "Status" : "Type";
     buf.append(`Total: ${filtered.length} packages`, "CocConverterTotal");
+    buf.append(`  |  `);
+    buf.append(`F:${filterLabel}(f)`, "CocConverterPill");
+    buf.append(`  `);
+    buf.append(`S:${sortLabel}(s)`, "CocConverterPill");
     if (state.statusMessage) {
       buf.append("  \xB7  ");
       buf.append(state.statusMessage, "Comment");
@@ -961,6 +1369,10 @@ var TUI = class {
     if (filtered.length === 0 && state.searchQuery) {
       buf.nl("no matching packages");
     }
+    buf.nl();
+    buf.append(" " + "\u2500".repeat(50), "Comment");
+    buf.nl();
+    buf.append(` ${filtered.length} packages \xB7 ${filterLabel} \xB7 ${sortLabel} order`, "Comment");
     const result = buf.render(2);
     return { lines: result.lines, pkgLineMap, logLines: logSet, highlights: result.highlights };
   }
@@ -969,7 +1381,12 @@ var TUI = class {
     const iconHl = entry.status === "installed" ? "CocConverterInstalled" : entry.status === "failed" ? "ErrorMsg" : "CocConverterAvailable";
     const pkgLine = buf.currentLine();
     pkgLineMap.set(pkgLine, entry.info.name);
-    buf.append(" ");
+    if (entry.marked) {
+      buf.append("\u25B8", "CocConverterKey");
+      buf.append(" ");
+    } else {
+      buf.append("  ");
+    }
     buf.append(icon, iconHl);
     buf.append(" ");
     buf.append(entry.info.displayName);
@@ -989,15 +1406,17 @@ var TUI = class {
     }
     if (entry.expanded) {
       buf.nl();
-      for (const text of [
+      const extras = [
         entry.info.description,
         `type        ${entry.info.type}`,
         entry.commit ? `commit      ${entry.commit}` : null,
         `source      ${sourceStr(entry.info.source)}`,
         `languages   ${entry.info.languages.join(", ")}`,
         `categories  ${entry.info.categories.join(", ")}`,
-        `homepage    ${entry.info.url}`
-      ].filter(Boolean)) {
+        `homepage    ${entry.info.url}`,
+        entry.info.serverBinary ? `server      ${entry.info.serverBinary.repo} (binary release)` : null
+      ];
+      for (const text of extras.filter(Boolean)) {
         const ln = buf.currentLine();
         buf.nl(`     ${text}`);
         pkgLineMap.set(ln, entry.info.name);
@@ -1033,9 +1452,6 @@ var TUI = class {
     }
     buf.nl();
   }
-  hl(line, hlGroup, colStart, colEnd) {
-    this.hlLines.push({ line, hlGroup, colStart, colEnd });
-  }
   isOpen() {
     return this.winid !== 0;
   }
@@ -1051,7 +1467,7 @@ var currentTUI = null;
 async function activate(context) {
   const state = new StateManager(createInitialState());
   context.subscriptions.push(
-    import_coc2.commands.registerCommand("loader.open", async () => {
+    import_coc3.commands.registerCommand("loader.open", async () => {
       if (currentTUI && currentTUI.isOpen()) {
         await currentTUI.close();
       }
@@ -1060,94 +1476,111 @@ async function activate(context) {
     })
   );
   context.subscriptions.push(
-    import_coc2.commands.registerCommand("loader.install", async (name) => {
+    import_coc3.commands.registerCommand("loader.install", async (name) => {
       if (!name) {
-        name = await import_coc2.workspace.nvim.call("input", ["Plugin name: ", ""]);
+        name = await import_coc3.workspace.nvim.call("input", ["Plugin name: ", ""]);
         if (!name) return;
       }
       const pkg = state.getPackage(name);
       if (!pkg) {
-        import_coc2.window.showInformationMessage(`Unknown package: ${name}`);
+        import_coc3.window.showInformationMessage(`Unknown package: ${name}`);
         return;
       }
       if (pkg.status === "installed") {
-        import_coc2.window.showInformationMessage(`${name} is already installed`);
+        import_coc3.window.showInformationMessage(`${name} is already installed`);
         return;
       }
       await installPackage(state, name);
     })
   );
   context.subscriptions.push(
-    import_coc2.commands.registerCommand("loader.uninstall", async (name) => {
+    import_coc3.commands.registerCommand("loader.uninstall", async (name) => {
       if (!name) {
-        name = await import_coc2.workspace.nvim.call("input", ["Plugin name: ", ""]);
+        name = await import_coc3.workspace.nvim.call("input", ["Plugin name: ", ""]);
         if (!name) return;
       }
       const pkg = state.getPackage(name);
       if (!pkg) {
-        import_coc2.window.showInformationMessage(`Unknown package: ${name}`);
+        import_coc3.window.showInformationMessage(`Unknown package: ${name}`);
         return;
       }
       if (pkg.status !== "installed") {
-        import_coc2.window.showInformationMessage(`${name} is not installed`);
+        import_coc3.window.showInformationMessage(`${name} is not installed`);
         return;
       }
       uninstallPackage(state, name);
     })
   );
   context.subscriptions.push(
-    import_coc2.commands.registerCommand("loader.update", async (name) => {
+    import_coc3.commands.registerCommand("loader.update", async (name) => {
       if (!name) {
-        name = await import_coc2.workspace.nvim.call("input", ["Plugin name: ", ""]);
+        name = await import_coc3.workspace.nvim.call("input", ["Plugin name: ", ""]);
         if (!name) return;
       }
       const pkg = state.getPackage(name);
       if (!pkg) {
-        import_coc2.window.showInformationMessage(`Unknown package: ${name}`);
+        import_coc3.window.showInformationMessage(`Unknown package: ${name}`);
         return;
       }
       if (pkg.status !== "installed") {
-        import_coc2.window.showInformationMessage(`${name} is not installed`);
+        import_coc3.window.showInformationMessage(`${name} is not installed`);
         return;
       }
       await updatePackage(state, name);
     })
   );
   context.subscriptions.push(
-    import_coc2.commands.registerCommand("loader.uninstallAll", async () => {
+    import_coc3.commands.registerCommand("loader.uninstallAll", async () => {
       const installed = state.getState().packages.filter((p) => p.status === "installed");
       if (installed.length === 0) {
-        import_coc2.window.showInformationMessage("No packages installed");
+        import_coc3.window.showInformationMessage("No packages installed");
         return;
       }
-      const ok = await import_coc2.window.showPrompt(`Uninstall all ${installed.length} packages?`);
+      const ok = await import_coc3.window.showPrompt(`Uninstall all ${installed.length} packages?`);
       if (ok) {
         for (const pkg of installed) {
-          uninstallPackage(state, pkg.info.name);
+          await uninstallPackage(state, pkg.info.name);
         }
       }
     })
   );
   context.subscriptions.push(
-    import_coc2.commands.registerCommand("loader.updateRegistry", async () => {
+    import_coc3.commands.registerCommand("loader.reinstall", async (name) => {
+      if (!name) {
+        name = await import_coc3.workspace.nvim.call("input", ["Plugin name: ", ""]);
+        if (!name) return;
+      }
+      const pkg = state.getPackage(name);
+      if (!pkg) {
+        import_coc3.window.showInformationMessage(`Unknown package: ${name}`);
+        return;
+      }
+      if (pkg.status !== "installed") {
+        import_coc3.window.showInformationMessage(`${name} is not installed`);
+        return;
+      }
+      await uninstallPackage(state, name);
+      await installPackage(state, name);
+    })
+  );
+  context.subscriptions.push(
+    import_coc3.commands.registerCommand("loader.updateRegistry", async () => {
       try {
         const count = await updateRegistry();
-        import_coc2.window.showInformationMessage(`Registry updated: ${count} packages available. Restart coc to apply.`);
+        import_coc3.window.showInformationMessage(`Registry updated: ${count} packages available. Restart coc to apply.`);
       } catch (e) {
-        import_coc2.window.showErrorMessage(`Registry update failed: ${e.message}`);
+        import_coc3.window.showErrorMessage(`Registry update failed: ${e.message}`);
       }
     })
   );
   context.subscriptions.push(
-    import_coc2.commands.registerCommand("loader._dispatch", async (key) => {
+    import_coc3.commands.registerCommand("loader._dispatch", async (key) => {
       if (currentTUI) {
         await currentTUI.handleKey(key);
       }
     })
   );
-  updateRegistry().then(() => state.refreshPackages()).catch(() => {
-  });
-  import_coc2.window.showInformationMessage("coc-loader activated! Use :CocCommand loader.open");
+  import_coc3.window.showInformationMessage("coc-loader activated! Use :CocCommand loader.open");
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {