coc-vscode-loader 1.2.5 → 1.2.7

package/lib/index.js

@@ -39,7 +39,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "coc-vscode-loader",
-      version: "1.2.5",
+      version: "1.2.7",
       description: "Run VS Code extensions seamlessly in coc.nvim",
       main: "lib/index.js",
       keywords: [
@@ -167,22 +167,47 @@ function loadCache() {
   }
   return null;
 }
-async function fetchRegistryJSON(url) {
+async function fetchRegistryJSON(url, onProgress) {
   try {
     const ctrl = new AbortController();
     const t = setTimeout(() => ctrl.abort(), 1e4);
     const res = await fetch(url, { signal: ctrl.signal });
     clearTimeout(t);
     if (res.ok) {
-      const data = await res.json();
+      const total = parseInt(res.headers.get("content-length") || "0");
+      const reader = res.body.getReader();
+      const chunks = [];
+      let received = 0;
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        if (value) {
+          chunks.push(value);
+          received += value.length;
+          if (total && onProgress) {
+            onProgress(`Downloading registry... ${Math.round(received / total * 100)}%`);
+          }
+        }
+      }
+      if (onProgress) onProgress("Parsing registry entries...");
+      const buf = new Uint8Array(received);
+      let pos = 0;
+      for (const c of chunks) {
+        buf.set(c, pos);
+        pos += c.length;
+      }
+      const text = new TextDecoder().decode(buf);
+      const data = JSON.parse(text);
       if (Array.isArray(data)) return data;
     }
   } catch {
   }
   return new Promise((resolve2, reject) => {
-    (0, import_child_process.execFile)("curl", ["-sL", url], { encoding: "utf-8", maxBuffer: 5 * 1024 * 1024 }, (err, stdout) => {
+    if (onProgress) onProgress("Downloading registry (curl)...");
+    (0, import_child_process.execFile)("curl", ["-sL", "--compressed", url], { encoding: "utf-8", maxBuffer: 20 * 1024 * 1024 }, (err, stdout) => {
       if (err) reject(new Error(`curl failed: ${err.message}`));
       else {
+        if (onProgress) onProgress("Parsing registry entries...");
         try {
           const data = JSON.parse(stdout);
           if (!Array.isArray(data)) reject(new Error("Invalid registry format"));
@@ -194,10 +219,11 @@ async function fetchRegistryJSON(url) {
     });
   });
 }
-async function updateRegistry() {
+async function updateRegistry(onProgress) {
   const localPath = process.env.COC_REGISTRY_PATH || getLocalRegistryPath();
   if (localPath) {
     if (!fs.existsSync(localPath)) throw new Error(`Local registry not found: ${localPath}`);
+    if (onProgress) onProgress("Reading local registry...");
     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 });
@@ -205,11 +231,12 @@ async function updateRegistry() {
     cached = data2;
     return data2.length;
   }
-  const data = await fetchRegistryJSON(REMOTE_REGISTRY_URL);
+  const data = await fetchRegistryJSON(REMOTE_REGISTRY_URL, onProgress);
   if (!Array.isArray(data)) throw new Error("Invalid registry format");
   fs.mkdirSync(path.dirname(CACHE_PATH), { recursive: true });
   fs.writeFileSync(CACHE_PATH, JSON.stringify(data, null, 2));
   cached = data;
+  if (onProgress) onProgress(`Registry updated: ${data.length} packages`);
   return data.length;
 }
 function satisfiesVersion(required) {
@@ -236,12 +263,19 @@ function getPackage(name) {
 var path2 = __toESM(require("path"));
 var fs2 = __toESM(require("fs"));
 var os2 = __toESM(require("os"));
-function isInstalled(name) {
-  return fs2.existsSync(path2.join(os2.homedir(), ".config", "coc", "extensions", "node_modules", `coc-${name}`));
+var EXT_DIR = path2.join(os2.homedir(), ".config", "coc", "extensions", "node_modules");
+function getInstalledSet() {
+  try {
+    const entries = fs2.readdirSync(EXT_DIR);
+    return new Set(entries.filter((n) => n.startsWith("coc-")).map((n) => n.slice(4)));
+  } catch {
+    return /* @__PURE__ */ new Set();
+  }
 }
 function createInitialState() {
+  const installedSet = getInstalledSet();
   const packages = getAllPackages().map((info) => {
-    const installed = isInstalled(info.name);
+    const installed = installedSet.has(info.name);
     let commit;
     let commitMsg;
     let commitDate;
@@ -268,17 +302,22 @@ function createInitialState() {
       marked: false
     };
   });
-  return { packages, searchQuery: "", showHelp: false, activePill: null, dirty: false, viewFilter: "all", sortBy: "default" };
+  return { packages, searchQuery: "", showHelp: false, activePill: null, dirty: false, viewFilter: "all", sortBy: "default", scrollOffset: 0 };
 }
 var StateManager = class {
   constructor(initial) {
     this.listeners = /* @__PURE__ */ new Set();
     this.scheduled = false;
+    this.cachedFiltered = null;
+    this.cachedFilterKey = "";
     this.state = initial;
   }
   getState() {
     return this.state;
   }
+  filterKey() {
+    return `${this.state.viewFilter}|${this.state.searchQuery}|${this.state.sortBy}`;
+  }
   subscribe(fn) {
     this.listeners.add(fn);
     return () => this.listeners.delete(fn);
@@ -298,11 +337,15 @@ var StateManager = class {
       }
     });
   }
+  invalidateFilterCache() {
+    this.cachedFilterKey = "";
+  }
   setPackageStatus(name, status, extra) {
+    this.invalidateFilterCache();
     this.mutate((s) => {
       const pkg = s.packages.find((p) => p.info.name === name);
       if (pkg) {
-        if (status === "installing" || status === "updating" || status === "uninstalling") {
+        if ((status === "installing" || status === "updating" || status === "uninstalling") && pkg.status !== status) {
           pkg.progressLog = [];
         }
         pkg.status = status;
@@ -339,21 +382,25 @@ var StateManager = class {
   setViewFilter(filter) {
     this.mutate((s) => {
       s.viewFilter = filter;
+      s.scrollOffset = 0;
     });
   }
   cycleViewFilter() {
     this.mutate((s) => {
       s.viewFilter = s.viewFilter === "all" ? "installed" : s.viewFilter === "installed" ? "not-installed" : "all";
+      s.scrollOffset = 0;
     });
   }
   setSortBy(sortBy) {
     this.mutate((s) => {
       s.sortBy = sortBy;
+      s.scrollOffset = 0;
     });
   }
   cycleSortBy() {
     this.mutate((s) => {
       s.sortBy = s.sortBy === "default" ? "name" : s.sortBy === "name" ? "status" : s.sortBy === "status" ? "type" : "default";
+      s.scrollOffset = 0;
     });
   }
   setStatusMessage(msg) {
@@ -374,9 +421,19 @@ var StateManager = class {
   setSearchQuery(query) {
     this.mutate((s) => {
       s.searchQuery = query;
+      s.scrollOffset = 0;
+    });
+  }
+  setScrollOffset(n) {
+    this.mutate((s) => {
+      s.scrollOffset = n;
     });
   }
   getFilteredPackages() {
+    const key = this.filterKey();
+    if (this.cachedFiltered && this.cachedFilterKey === key) {
+      return this.cachedFiltered;
+    }
     let pkgs = this.state.packages;
     if (this.state.viewFilter === "not-installed") {
       pkgs = pkgs.filter((p) => p.status === "not-installed");
@@ -398,6 +455,8 @@ var StateManager = class {
     } else if (sortBy === "type") {
       pkgs = [...pkgs].sort((a, b) => a.info.type.localeCompare(b.info.type));
     }
+    this.cachedFiltered = pkgs;
+    this.cachedFilterKey = key;
     return pkgs;
   }
   getPackage(name) {
@@ -418,6 +477,8 @@ var StateManager = class {
     return this.state.packages.filter((p) => p.marked).map((p) => p.info.name);
   }
   refreshPackages() {
+    this.invalidateFilterCache();
+    const installedSet = getInstalledSet();
     this.mutate((s) => {
       const updated = getAllPackages();
       const oldMap = new Map(s.packages.map((p) => [p.info.name, p]));
@@ -429,7 +490,7 @@ var StateManager = class {
         }
         return {
           info,
-          status: isInstalled(info.name) ? "installed" : "not-installed",
+          status: installedSet.has(info.name) ? "installed" : "not-installed",
           progressLog: [],
           expanded: false,
           logExpanded: false,
@@ -511,16 +572,23 @@ 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(), "");
+  let output = "";
   if (fs3.existsSync(srcDir)) {
     onProgress(1, 5, "Updating source...", `git -C ${srcDir} pull`);
+    const log = (chunk) => {
+      output += chunk;
+      onProgress(1, 5, "Updating source...", chunk.trim());
+    };
     await run("git", ["-C", srcDir, "pull"], cache, log);
   } else {
     onProgress(1, 5, "Cloning repository...", `git clone --depth=1 ${repoUrl}`);
     fs3.mkdirSync(cache, { recursive: true });
+    const log = (chunk) => onProgress(1, 5, "Cloning repository...", chunk.trim());
     await run("git", ["clone", "--depth=1", repoUrl, srcDir], cache, log);
   }
-  return info.source.subdir ? path3.join(srcDir, info.source.subdir) : srcDir;
+  const dir = info.source.subdir ? path3.join(srcDir, info.source.subdir) : srcDir;
+  const updated = !output.includes("Already up to date.");
+  return { dir, updated };
 }
 async function convertSource(inputDir, name, info, onProgress) {
   const build = buildDir(name);
@@ -582,8 +650,11 @@ async function buildPackage(name, inputDir, info, onProgress) {
   onProgress(3, 5, "Installing dependencies...", "npm install --legacy-peer-deps");
   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, npmLog).catch(() => {
-  });
+  try {
+    await run("npm", ["run", "postinstall", "--if-present"], build, npmLog);
+  } catch (e) {
+    onProgress(3, 5, `Warning: postinstall failed (${e.message})`, "may affect plugin functionality");
+  }
   if (info.pipPackages?.length) {
     const pipLog = (chunk) => onProgress(3, 5, chunk.trim(), "");
     const pythonPaths = [
@@ -733,9 +804,9 @@ async function installToCoc(name, onProgress) {
   const depName = `coc-${name}`;
   if (!pkg.dependencies[depName]) {
     pkg.dependencies[depName] = `file:${dest}`;
-    pkg.lastUpdate = Date.now();
-    fs3.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2));
   }
+  pkg.lastUpdate = Date.now();
+  fs3.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2));
 }
 function metaPath(name) {
   return path3.join(cacheDir(name), "meta.json");
@@ -759,13 +830,12 @@ async function installPackage(state, name) {
     state.setPackageStatus(name, "installing", {
       progress: `[${step}/${total}] ${msg}`,
       logEntry: `[${step}/${total}] ${msg}
-  $ ${cmd}`,
-      appendLog: true
+  $ ${cmd}`
     });
   };
   state.setPackageStatus(name, "installing", { progress: "Starting..." });
   try {
-    const input = await downloadSource(info, name, prog);
+    const { dir: input } = await downloadSource(info, name, prog);
     await convertSource(input, name, info, prog);
     await buildPackage(name, input, info, prog);
     await installToCoc(name, prog);
@@ -838,13 +908,17 @@ async function updatePackage(state, name) {
     state.setPackageStatus(name, "updating", {
       progress: `[${step}/${total}] ${msg}`,
       logEntry: `[${step}/${total}] ${msg}
-  $ ${cmd}`,
-      appendLog: true
+  $ ${cmd}`
     });
   };
   state.setPackageStatus(name, "updating", { progress: "Starting..." });
   try {
-    const input = await downloadSource(info, name, prog);
+    const { dir: input, updated } = await downloadSource(info, name, prog);
+    if (!updated) {
+      state.setPackageStatus(name, "installed");
+      import_coc.window.showInformationMessage(`coc-${name} is already up to date`);
+      return;
+    }
     await convertSource(input, name, info, prog);
     await buildPackage(name, input, info, prog);
     await installToCoc(name, prog);
@@ -898,41 +972,51 @@ async function runWithOutput(cmd, args, cwd) {
 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));
+    const p = fn(item).catch(() => {
+    }).finally(() => pool.delete(p));
     pool.add(p);
     if (pool.size >= concurrency) {
       await Promise.race(pool);
     }
   }
-  await Promise.all(pool);
+  await Promise.allSettled(pool);
 }
+var checkUpdatesBusy = false;
 async function checkUpdates(state) {
-  const s = state.getState();
-  const results = {};
-  state.setStatusMessage("Checking for updates...");
-  for (const pkg of s.packages) {
-    if (pkg.status !== "installed" || !pkg.commit) continue;
-    state.setStatusMessage(`Checking ${pkg.info.displayName}...`);
-    try {
-      const out = await runWithOutput("git", ["ls-remote", `https://github.com/${pkg.info.source.repo}.git`, "HEAD"], os3.homedir());
-      const remote = out.split("	")[0];
-      if (remote) results[pkg.info.name] = remote.substring(0, 7) !== pkg.commit;
-    } catch {
+  if (checkUpdatesBusy) return;
+  checkUpdatesBusy = true;
+  try {
+    const s = state.getState();
+    const results = {};
+    state.setStatusMessage("Checking for updates...");
+    for (const pkg of s.packages) {
+      if (pkg.status !== "installed" || !pkg.commit) continue;
+      const live = state.getPackage(pkg.info.name);
+      if (!live || live.status !== "installed" || !live.commit) continue;
+      state.setStatusMessage(`Checking ${pkg.info.displayName}...`);
+      try {
+        const out = await runWithOutput("git", ["ls-remote", `https://github.com/${pkg.info.source.repo}.git`, "HEAD"], os3.homedir());
+        const remote = out.split("	")[0];
+        if (remote) results[pkg.info.name] = remote.substring(0, 7) !== live.commit;
+      } catch {
+      }
     }
-  }
-  const updateCount = Object.values(results).filter(Boolean).length;
-  state.mutate((s2) => {
-    for (const p of s2.packages) {
-      if (results[p.info.name] !== void 0) p.hasUpdate = results[p.info.name];
+    const updateCount = Object.values(results).filter(Boolean).length;
+    state.mutate((s2) => {
+      for (const p of s2.packages) {
+        if (results[p.info.name] !== void 0) p.hasUpdate = results[p.info.name];
+      }
+      s2.statusMessage = void 0;
+    });
+    if (updateCount > 0) {
+      state.setStatusMessage(`Found ${updateCount} package(s) with updates. Use 'u' to update.`);
+      setTimeout(() => state.setStatusMessage(), 5e3);
+    } else {
+      state.setStatusMessage("All packages up to date.");
+      setTimeout(() => state.setStatusMessage(), 3e3);
     }
-    s2.statusMessage = void 0;
-  });
-  if (updateCount > 0) {
-    state.setStatusMessage(`Found ${updateCount} package(s) with updates. Use 'u' to update.`);
-    setTimeout(() => state.setStatusMessage(), 5e3);
-  } else {
-    state.setStatusMessage("All packages up to date.");
-    setTimeout(() => state.setStatusMessage(), 3e3);
+  } finally {
+    checkUpdatesBusy = false;
   }
 }
 
@@ -962,6 +1046,13 @@ var LineBuffer = class {
   currentLine() {
     return this.li;
   }
+  currentByteLen() {
+    let len = 0;
+    for (const seg of this.lines[this.li]) {
+      len += byteLen(seg.text);
+    }
+    return len;
+  }
   highlight(pattern, hlGroup) {
     const segs = this.lines[this.li];
     let full = "";
@@ -1028,10 +1119,11 @@ var HELP_TEXT = [
   "    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",
+  "    j/k        Scroll through packages",
+  "    /          Search filter (then j/k to scroll)",
+  "    gg         Jump to first page",
+  "    G          Jump to last page",
+  "    <Enter>    Open detail popup (description, source, log)",
   "    q          Close window",
   "    <Esc>      Help\u2192Search\u2192Marks\u2192Busy guard\u2192Close",
   "",
@@ -1042,7 +1134,7 @@ var HELP_TEXT = [
   "    pure-lsp    Standard LSP protocol (e.g. Prisma, ESLint)",
   "    direct-api  Direct coc.nvim API calls (e.g. HTML CSS Support)"
 ];
-var TUI = class {
+var TUI = class _TUI {
   constructor(state) {
     this.bufnr = 0;
     this.winid = 0;
@@ -1051,11 +1143,20 @@ var TUI = class {
     this.unsubscribe = null;
     this.pkgLineMap = /* @__PURE__ */ new Map();
     this.logLineSet = /* @__PURE__ */ new Set();
+    this.detailWinid = 0;
+    this.detailBufnr = 0;
+    this.detailPkgName = "";
+    this.detailMode = "info";
+    this.windowHeight = 0;
+    this.windowWidth = 0;
     this.keyMap = {
       q: "q",
       esc: "<Esc>",
       question: "?",
       slash: "/",
+      j: "j",
+      k: "k",
+      "close-detail": "close-detail",
       U: "U",
       Z: "Z",
       i: "i",
@@ -1072,8 +1173,16 @@ var TUI = class {
     };
     this.rendering = false;
     this.pendingRender = false;
+    this.focusIndex = 0;
+    this.focusLineOffset = 0;
     this.state = state;
   }
+  static {
+    this.HEADER_LINES = 6;
+  }
+  static {
+    this.FOOTER_LINES = 3;
+  }
   async open() {
     const nvim = import_coc2.workspace.nvim;
     this.ns = await nvim.createNamespace("coc-loader");
@@ -1091,7 +1200,9 @@ var TUI = class {
     const editorLines = await nvim.call("nvim_get_option", ["lines"]);
     const editorCols = await nvim.call("nvim_get_option", ["columns"]);
     const height = Math.min(Math.floor(editorLines * 0.85), 40);
+    this.windowHeight = height - 2;
     const width = Math.min(Math.floor(editorCols * 0.85), 120);
+    this.windowWidth = width - 2;
     const row = Math.max(Math.floor((editorLines - height) / 2), 0);
     const col = Math.max(Math.floor((editorCols - width) / 2), 0);
     const win = await nvim.openFloatWindow(buf, true, {
@@ -1100,7 +1211,7 @@ var TUI = class {
       height,
       row,
       col,
-      border: "none",
+      border: "rounded",
       style: "minimal"
     });
     this.winid = win.id;
@@ -1131,7 +1242,7 @@ var TUI = class {
           const curBuf = await nvim.call("winbufnr", [curWin]);
           const bt = await nvim.call("getbufvar", [curBuf, "&buftype"]);
           if (bt !== "nofile" && bt !== "prompt") {
-            this.close();
+            await this.close();
           }
         }
       })
@@ -1146,7 +1257,12 @@ var TUI = class {
     }
     await this.setupKeymaps();
     await this.render();
-    updateRegistry().then(() => {
+    this.state.setStatusMessage("Fetching registry...");
+    const onProgress = (msg) => {
+      this.state.setStatusMessage(msg);
+    };
+    updateRegistry(onProgress).then(() => {
+      this.state.setStatusMessage();
       this.state.refreshPackages();
       this.render();
     }).catch(() => {
@@ -1160,14 +1276,23 @@ var TUI = class {
     return cursor[0] - 1;
   }
   async handleKey(id) {
+    if (!this.winid) return;
     const line0 = await this.getCursorLine0();
     const s = this.state.getState();
     if (id === "q") {
-      this.close();
+      await this.close();
       return;
     }
     if (id === "I") {
       this.state.setActivePill("I");
+      const marked = this.state.getMarkedNames();
+      if (marked.length === 0) {
+        import_coc2.window.showInformationMessage("No packages marked. Use x to mark packages.");
+        this.state.setActivePill(null);
+        return;
+      }
+      await runConcurrent(marked, (name) => installPackage(this.state, name));
+      this.state.setActivePill(null);
       return;
     }
     if (id === "H") {
@@ -1195,7 +1320,7 @@ var TUI = class {
         import_coc2.window.showInformationMessage("Operation in progress, wait for it to finish");
         return;
       }
-      this.close();
+      await this.close();
       return;
     }
     if (id === "question") {
@@ -1212,23 +1337,62 @@ var TUI = class {
     }
     if (id === "f") {
       this.state.cycleViewFilter();
+      this.focusIndex = 0;
       return;
     }
     if (id === "s") {
       this.state.cycleSortBy();
+      this.focusIndex = 0;
       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]]);
-      }
+      this.state.setScrollOffset(0);
+      this.focusIndex = 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]]);
+      const filtered = this.state.getFilteredPackages();
+      const visibleCount = Math.max(1, this.windowHeight - _TUI.HEADER_LINES - _TUI.FOOTER_LINES);
+      this.state.setScrollOffset(Math.max(0, filtered.length - visibleCount));
+      this.focusIndex = Math.max(0, filtered.length - 1);
+      return;
+    }
+    if (id === "j") {
+      const filtered = this.state.getFilteredPackages();
+      if (this.focusIndex < filtered.length - 1) {
+        this.focusIndex++;
+        this.focusLineOffset = 0;
+        const s2 = this.state.getState();
+        const visibleCount = Math.max(1, this.windowHeight - _TUI.HEADER_LINES - _TUI.FOOTER_LINES);
+        if (this.focusIndex >= s2.scrollOffset + visibleCount) {
+          s2.scrollOffset = Math.min(Math.max(0, filtered.length - visibleCount), s2.scrollOffset + 1);
+          await this.render();
+          return;
+        }
+        const focused = filtered[this.focusIndex];
+        const pkgLine = [...this.pkgLineMap.entries()].find(([l, n]) => n === focused.info.name)?.[0];
+        if (pkgLine !== void 0) {
+          await import_coc2.workspace.nvim.call("nvim_win_set_cursor", [this.winid, [pkgLine + 1, 0]]);
+        }
+      }
+      return;
+    }
+    if (id === "k") {
+      if (this.focusIndex > 0) {
+        this.focusIndex--;
+        this.focusLineOffset = 0;
+        const s2 = this.state.getState();
+        if (this.focusIndex < s2.scrollOffset) {
+          s2.scrollOffset = Math.max(0, s2.scrollOffset - 1);
+          await this.render();
+          return;
+        }
+        const filtered = this.state.getFilteredPackages();
+        const focused = filtered[this.focusIndex];
+        const pkgLine = [...this.pkgLineMap.entries()].find(([l, n]) => n === focused.info.name)?.[0];
+        if (pkgLine !== void 0) {
+          await import_coc2.workspace.nvim.call("nvim_win_set_cursor", [this.winid, [pkgLine + 1, 0]]);
+        }
       }
       return;
     }
@@ -1294,12 +1458,12 @@ var TUI = class {
       await installPackage(this.state, pkgName);
       return;
     }
+    if (id === "close-detail") {
+      this.closeDetailPopup();
+      return;
+    }
     if (id === "cr") {
-      if (this.logLineSet.has(line0)) {
-        this.state.toggleLog(pkgName);
-      } else {
-        this.state.toggleExpand(pkgName);
-      }
+      if (pkgName) await this.showDetailPopup(pkgName);
       return;
     }
   }
@@ -1323,6 +1487,8 @@ var TUI = class {
       ["s", "s"],
       ["x", "x"],
       ["D", "D"],
+      ["j", "j"],
+      ["k", "k"],
       ["gg", "gg"],
       ["G", "G"],
       ["<CR>", "cr"]
@@ -1341,6 +1507,13 @@ var TUI = class {
       d.dispose();
     }
     this.disposables = [];
+    if (this.detailWinid) {
+      try {
+        import_coc2.workspace.nvim.call("nvim_win_close", [this.detailWinid, true]);
+      } catch {
+      }
+      this.detailWinid = 0;
+    }
     if (this.winid) {
       try {
         await import_coc2.workspace.nvim.call("nvim_win_close", [this.winid, true]);
@@ -1365,19 +1538,49 @@ var TUI = class {
       const state = this.state.getState();
       const filtered = this.state.getFilteredPackages();
       const result = state.showHelp ? this.renderHelp() : this.renderPackageList(state, filtered);
+      if (this.windowWidth > 0) {
+        result.highlights = result.highlights.filter((h) => h.colStart < this.windowWidth);
+        for (const h of result.highlights) {
+          if (h.colEnd > this.windowWidth) h.colEnd = this.windowWidth;
+        }
+      }
       nvim.pauseNotification();
-      nvim.call("nvim_buf_set_option", [this.bufnr, "modifiable", true], true);
-      nvim.call("nvim_buf_clear_namespace", [this.bufnr, this.ns, 0, -1], true);
-      nvim.call("nvim_buf_set_lines", [this.bufnr, 0, -1, false, result.lines], true);
-      nvim.call("nvim_buf_set_option", [this.bufnr, "modifiable", false], true);
-      for (const h of result.highlights) {
-        nvim.call("nvim_buf_set_extmark", [this.bufnr, this.ns, h.line, h.colStart, {
-          end_col: h.colEnd,
-          hl_group: h.hlGroup,
-          hl_mode: "combine"
-        }], true);
+      try {
+        nvim.call("nvim_buf_set_option", [this.bufnr, "modifiable", true], true);
+        nvim.call("nvim_buf_clear_namespace", [this.bufnr, this.ns, 0, -1], true);
+        nvim.call("nvim_buf_set_lines", [this.bufnr, 0, -1, false, result.lines], true);
+        nvim.call("nvim_buf_set_option", [this.bufnr, "modifiable", false], true);
+        for (const h of result.highlights) {
+          nvim.call("nvim_buf_set_extmark", [this.bufnr, this.ns, h.line, h.colStart, {
+            end_col: h.colEnd,
+            hl_group: h.hlGroup,
+            hl_mode: "combine"
+          }], true);
+        }
+      } finally {
+        await nvim.resumeNotification();
+      }
+      if (this.detailWinid) {
+        this.updateDetailPopup().catch(() => {
+        });
+      }
+      if (!state.showHelp && result.pkgLineMap.size > 0) {
+        const visibleCount = Math.max(1, this.windowHeight - _TUI.HEADER_LINES - _TUI.FOOTER_LINES);
+        if (this.focusIndex < state.scrollOffset) {
+          state.scrollOffset = this.focusIndex;
+        } else if (this.focusIndex >= state.scrollOffset + visibleCount) {
+          state.scrollOffset = Math.max(0, this.focusIndex - visibleCount + 1);
+        }
+        const visible = this.state.getFilteredPackages();
+        const idx = Math.min(this.focusIndex, visible.length - 1);
+        const focused = visible[idx];
+        if (focused) {
+          const targetLine = [...result.pkgLineMap.entries()].find(([l, n]) => n === focused.info.name)?.[0];
+          if (targetLine !== void 0) {
+            await nvim.call("nvim_win_set_cursor", [this.winid, [targetLine + 1, 0]]);
+          }
+        }
       }
-      await nvim.resumeNotification();
       this.pkgLineMap = result.pkgLineMap;
       this.logLineSet = result.logLines;
     } finally {
@@ -1443,30 +1646,31 @@ var TUI = class {
     }
     buf.nl();
     buf.nl();
-    const installed = filtered.filter((e) => e.status !== "not-installed");
-    const available = filtered.filter((e) => e.status === "not-installed");
-    const section = (title, entries) => {
-      if (entries.length === 0) return;
-      buf.nl(`${title}`);
-      for (const e of entries) {
-        this.renderEntry(buf, pkgLineMap, logSet, e);
-      }
-      buf.nl();
-      buf.nl();
-    };
-    section(`Installed (${installed.length})`, installed);
-    section(`Available (${available.length})`, available);
+    const visibleCount = Math.max(1, this.windowHeight - _TUI.HEADER_LINES - _TUI.FOOTER_LINES);
+    const maxOffset = Math.max(0, filtered.length - visibleCount);
+    const start = Math.min(state.scrollOffset, maxOffset);
+    const end = Math.min(start + visibleCount, filtered.length);
+    const visible = filtered.slice(start, end);
+    const indicator = filtered.length > visibleCount ? `${start + 1}\u2013${end} of ${filtered.length}` : `${filtered.length} packages`;
+    buf.append(indicator, "CocConverterTotal");
+    buf.nl();
+    buf.nl();
+    for (const e of visible) {
+      this.renderEntry(buf, pkgLineMap, logSet, e);
+    }
     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 filterLabel2 = state.viewFilter === "all" ? "All" : state.viewFilter === "installed" ? "Installed" : "Available";
+    const sortLabel2 = state.sortBy === "default" ? "Default" : state.sortBy === "name" ? "Name" : state.sortBy === "status" ? "Status" : "Type";
+    buf.append(` ${filtered.length} packages \xB7 ${filterLabel2} \xB7 ${sortLabel2}`, "Comment");
     const result = buf.render(2);
     return { lines: result.lines, pkgLineMap, logLines: logSet, highlights: result.highlights };
   }
-  renderEntry(buf, pkgLineMap, logSet, entry) {
+  renderEntry(buf, pkgLineMap, _logSet, entry) {
     const icon = entry.status === "installed" ? "\u25CF" : entry.status === "failed" ? "\u2717" : "\u25CB";
     const iconHl = entry.status === "installed" ? "CocConverterInstalled" : entry.status === "failed" ? "ErrorMsg" : "CocConverterAvailable";
     const pkgLine = buf.currentLine();
@@ -1480,67 +1684,153 @@ var TUI = class {
     buf.append(icon, iconHl);
     buf.append(" ");
     buf.append(entry.info.displayName);
+    let statusText = "";
+    let statusHl = "";
+    if (entry.progress) {
+      statusText = `  ${entry.progress}`;
+      statusHl = "Comment";
+    } else if (entry.status === "failed" && entry.error) {
+      statusText = `  \u2717 ${entry.error}`;
+      statusHl = "ErrorMsg";
+    }
     buf.append(" ");
     buf.append(entry.info.type, "CocConverterType");
+    if (statusText) {
+      buf.append(statusText, statusHl);
+    }
     if (entry.hasUpdate) {
       buf.append("  \u2191", "CocConverterKey");
     }
-    if (entry.updated && entry.commit && entry.commitMsg) {
-      buf.nl();
-      const ln = buf.currentLine();
-      buf.append(`     ${entry.commit} ${entry.commitMsg}`, "Comment");
-      if (entry.commitDate) {
-        buf.append(` (${entry.commitDate})`, "Comment");
+    if (entry.commit && entry.commitMsg && entry.status === "installed") {
+      const cr = entry.commitDate ? ` (${entry.commitDate})` : "";
+      let msg = entry.commitMsg;
+      if (this.windowWidth > 0) {
+        const prefixLen = buf.currentByteLen();
+        const commitPrefix = `  ${entry.commit} `;
+        const suffix = cr;
+        const available = this.windowWidth - 2 - prefixLen - Buffer.from(commitPrefix).length - Buffer.from(suffix).length - 3;
+        if (available > 0 && Buffer.from(msg).length > available) {
+          while (Buffer.from(msg).length > available && msg.length > 0) {
+            msg = msg.slice(0, -1);
+          }
+          msg += "\u2026";
+        }
       }
-      pkgLineMap.set(ln, entry.info.name);
-    }
-    if (entry.expanded) {
-      buf.nl();
-      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}`,
-        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);
+      buf.append(`  ${entry.commit} ${msg}${cr}`, "Comment");
+    }
+    buf.nl();
+  }
+  buildDetailLines(entry, mode = "info") {
+    const lines = [];
+    if (mode === "log") {
+      for (const log of entry.progressLog) {
+        for (const l of log.split("\n")) {
+          lines.push(`  ${l}`);
+        }
       }
+      if (entry.error) lines.push("", `  \u2717 ${entry.error}`);
+      return lines;
     }
-    if (entry.progress) {
-      buf.nl();
-      if (entry.logExpanded) {
-        const ln = buf.currentLine();
-        buf.nl(`     \u25BC Install log:`);
-        logSet.add(ln);
-        pkgLineMap.set(ln, entry.info.name);
-        for (const log of entry.progressLog) {
-          for (const l of log.split("\n")) {
-            const ln2 = buf.currentLine();
-            buf.nl(`       ${l}`);
-            logSet.add(ln2);
-            pkgLineMap.set(ln2, entry.info.name);
-          }
+    lines.push(
+      `  desc     ${entry.info.description}`,
+      `  type     ${entry.info.type}`,
+      `  status   ${entry.status}`
+    );
+    if (entry.commit) lines.push(`  commit   ${entry.commit}`);
+    lines.push(
+      `  source   ${sourceStr(entry.info.source)}`,
+      `  langs    ${entry.info.languages.join(", ")}`,
+      `  cats     ${entry.info.categories.join(", ")}`,
+      `  link     ${entry.info.url}`
+    );
+    if (entry.info.serverBinary) {
+      lines.push(`  server   ${entry.info.serverBinary.repo}`);
+    }
+    return lines;
+  }
+  async showDetailPopup(name) {
+    if (this.detailWinid) this.closeDetailPopup();
+    this.detailPkgName = name;
+    const nvim = import_coc2.workspace.nvim;
+    const entry = this.state.getPackage(name);
+    if (!entry) return;
+    this.detailMode = ["installing", "updating", "uninstalling", "failed"].includes(entry.status) ? "log" : "info";
+    const editorLines = await nvim.call("nvim_get_option", ["lines"]);
+    const editorCols = await nvim.call("nvim_get_option", ["columns"]);
+    const lines = this.buildDetailLines(entry, this.detailMode);
+    const height = this.detailMode === "log" ? 20 : Math.min(lines.length, 20);
+    const row = Math.max(0, Math.floor((editorLines - height - 2) / 2));
+    const col = Math.max(0, Math.floor((editorCols - 82) / 2));
+    const buf = await nvim.createNewBuffer(false, true);
+    this.detailBufnr = buf.id;
+    const win = await nvim.openFloatWindow(buf, true, {
+      relative: "editor",
+      width: 78,
+      height,
+      row,
+      col,
+      border: "rounded",
+      style: "minimal",
+      zindex: 100,
+      title: this.detailMode === "log" ? `${entry.info.displayName}  \xB7  Log` : entry.info.displayName,
+      title_pos: "left"
+    });
+    this.detailWinid = win.id;
+    await nvim.call("nvim_win_set_option", [this.detailWinid, "wrap", true]);
+    await nvim.call("nvim_buf_set_option", [this.detailBufnr, "bufhidden", "wipe"]);
+    await nvim.call("nvim_buf_set_option", [this.detailBufnr, "buftype", "nofile"]);
+    const keyBuf = nvim.createBuffer(this.detailBufnr);
+    keyBuf.setKeymap("n", "q", '<Cmd>call CocConverterDispatch("close-detail")<CR>', { silent: true, nowait: true });
+    keyBuf.setKeymap("n", "<Esc>", '<Cmd>call CocConverterDispatch("close-detail")<CR>', { silent: true, nowait: true });
+    await this.updateDetailPopup();
+  }
+  async updateDetailPopup() {
+    if (!this.detailWinid || !this.detailPkgName) return;
+    const entry = this.state.getPackage(this.detailPkgName);
+    if (!entry) return;
+    const lines = this.buildDetailLines(entry, this.detailMode);
+    const nvim = import_coc2.workspace.nvim;
+    await nvim.call("nvim_buf_set_lines", [this.detailBufnr, 0, -1, false, lines]);
+    await nvim.call("nvim_buf_clear_namespace", [this.detailBufnr, this.ns, 0, -1]);
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      if (line.startsWith("  [")) {
+        const endBracket = line.indexOf("]");
+        if (endBracket > 0) {
+          nvim.call("nvim_buf_set_extmark", [this.detailBufnr, this.ns, i, 2, { end_col: endBracket + 1, hl_group: "CocConverterKey" }]);
+          nvim.call("nvim_buf_set_extmark", [this.detailBufnr, this.ns, i, endBracket + 1, { end_col: line.length, hl_group: "Comment" }]);
+        }
+      } else if (line.startsWith("  $ ")) {
+        nvim.call("nvim_buf_set_extmark", [this.detailBufnr, this.ns, i, 0, { end_col: line.length, hl_group: "Comment" }]);
+      } else if (line.includes("\u2717") || line.includes("Error:")) {
+        nvim.call("nvim_buf_set_extmark", [this.detailBufnr, this.ns, i, 0, { end_col: line.length, hl_group: "ErrorMsg" }]);
+      } else if (line.match(/^\s{4}at\s/) || line.match(/^\s{4}Node\.js/)) {
+        nvim.call("nvim_buf_set_extmark", [this.detailBufnr, this.ns, i, 0, { end_col: line.length, hl_group: "Comment" }]);
+      } else if (line.match(/^\s{2}\w+\s{3,}/)) {
+        const parts = line.substring(2).split(/\s{2,}/);
+        if (parts.length >= 2 && ["desc", "type", "status", "source", "langs", "cats", "link", "commit", "server"].includes(parts[0])) {
+          const labelEnd = 2 + parts[0].length + line.substring(2 + parts[0].length).match(/^\s*/)[0].length;
+          nvim.call("nvim_buf_set_extmark", [this.detailBufnr, this.ns, i, 2, { end_col: labelEnd, hl_group: "CocConverterKey" }]);
+          nvim.call("nvim_buf_set_extmark", [this.detailBufnr, this.ns, i, labelEnd, { end_col: line.length, hl_group: "Comment" }]);
         }
-      } else {
-        const ln = buf.currentLine();
-        buf.nl(`     \u25B6 ${entry.progress}`);
-        logSet.add(ln);
-        pkgLineMap.set(ln, entry.info.name);
       }
     }
-    if (entry.error) {
-      buf.nl();
-      const ln = buf.currentLine();
-      buf.nl(`     \u2717 ${entry.error}`);
-      pkgLineMap.set(ln, entry.info.name);
+    if (this.detailMode === "log") {
+      await nvim.call("nvim_win_set_cursor", [this.detailWinid, [lines.length, 0]]);
     }
-    buf.nl();
+  }
+  closeDetailPopup() {
+    if (!this.detailWinid) return;
+    try {
+      import_coc2.workspace.nvim.call("nvim_win_close", [this.detailWinid, true]);
+    } catch {
+    }
+    this.detailWinid = 0;
+    this.detailBufnr = 0;
+    this.detailPkgName = "";
+    this.detailMode = "info";
+    this.render().catch(() => {
+    });
   }
   isOpen() {
     return this.winid !== 0;
@@ -1598,7 +1888,7 @@ async function activate(context) {
         import_coc3.window.showInformationMessage(`${name} is not installed`);
         return;
       }
-      uninstallPackage(state, name);
+      await uninstallPackage(state, name);
     })
   );
   context.subscriptions.push(