coc-vscode-loader 1.2.6 → 1.2.7

package/README.md

@@ -37,10 +37,10 @@ npm install coc-vscode-loader
 | `x` | Toggle mark package for batch operations |
 | `f` | Cycle filter: all → installed → available |
 | `s` | Cycle sort: default → name → status → type |
-| `[` / `]` | Previous / next page |
-| `gg` | Jump to first page |
-| `G` | Jump to last page |
-| `<CR>` | Toggle details (commit / type / source) or install log |
+| `j` / `k` | Scroll through packages (virtual scroll) |
+| `gg` | Jump to first package |
+| `G` | Jump to last package |
+| `<CR>` | Open detail popup (info / install log with syntax highlights) |
 | `/` | Search filter |
 | `q` | Close (auto `:CocRestart` if changes detected) |
 | `<Esc>` | Help→Search→Clear marks→Cancel|Close |
@@ -61,13 +61,13 @@ npm install coc-vscode-loader
 
 - **Real conversion pipeline** — git clone → converter → npm install → esbuild → register to coc
 - **Auto-fetch registry** — remote registry fetched in background when TUI opens, no manual refresh needed
-- **Pagination** — `[`/`]` prev/next page, 50 packages per page, handles 5000+ registry entries
+- **Virtual scrolling** — `j`/`k` smooth scroll through packages, handles 100k+ registry entries
 - **Incremental cache** — source/ keeps git repo, updates via git pull only
 - **Commit tracking** — records commit SHA after install, visible in detail view
 - **Update check** — `C` key compares against remote HEAD, shows `↑` when outdated
 - **Auto restart** — `:CocRestart` triggered automatically on close when changes detected
 - **Manual registry update** — `:CocCommand loader.updateRegistry` also available for re-fetch
-- **Install logs** — real command output per step, expandable
+- **Detail popup** — `<CR>` opens centered float window with package info or live install log (syntax highlighted, auto-scroll to latest)
 - **Mark & batch** — `x` toggle mark, visual indicator, `D` clean orphaned packages
 - **Filter & sort** — `f` cycle view filter, `s` cycle sort order (name/status/type)
 - **Concurrency limit** — max 3 parallel operations for `U` (Update All)

package/converter/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "converter",
-  "version": "1.2.6",
+  "version": "1.2.7",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "converter",
-      "version": "1.2.6",
+      "version": "1.2.7",
       "dependencies": {
         "commander": "^15.0.0",
         "ts-morph": "^28.0.0",

package/converter/package.json

@@ -1,6 +1,6 @@
 {
   "name": "converter",
-  "version": "1.2.6",
+  "version": "1.2.7",
   "private": true,
   "description": "vscode → coc.nvim converter prototype",
   "type": "module",

package/converter/src/scanner.ts

@@ -23,7 +23,7 @@ export function scan(dir: string): ScanResult {
     const apis: string[] = []
     const relative = path.relative(dir, filePath)
 
-    if (content.includes("from 'vscode'") || content.includes('from "vscode"') || content.includes('require("vscode")')) {
+    if (content.includes("from 'vscode'") || content.includes('from "vscode"') || content.includes('require("vscode")') || content.includes("require('vscode')")) {
       apis.push('vscode')
     }
 

package/converter/src/steps/language-client.ts

@@ -108,7 +108,7 @@ ${ls.verbose ? `    console.log('[${escapeStr(id)}] creating LanguageClient')\n`
         {
           documentSelector: ${docSelectorCode},
           outputChannelName: '${escapeStr(description)}',
-          ${ls.initializationOptions ? `initializationOptions: ${ls.initializationOptions},` : ''}
+          ${ls.initializationOptions ? `initializationOptions: ${ls.initializationOptions.replace(/`/g, '\\`').replace(/\$\{/g, '\\${')},` : ''}
         },
       )
       context.subscriptions.push({ dispose: () => c.stop() })
@@ -117,23 +117,27 @@ ${ls.verbose ? `    console.log('[${escapeStr(id)}] creating LanguageClient')\n`
     }
 
 ${ls.verbose ? `    console.log('[${escapeStr(id)}] registering LanguageClient')\n` : ''}\
-    let client: LanguageClient
+    let clients: LanguageClient[]
     if (${multiRoot ? 'workspace.workspaceFolders && workspace.workspaceFolders.length > 1' : 'false'}) {
 ${ls.verbose ? `      console.log('[${escapeStr(id)}] multiRoot mode')\n` : ''}\
-      for (const folder of workspace.workspaceFolders) {
-        client = createClient()
-        client.start()
-      }
+      clients = workspace.workspaceFolders.map(folder => {
+        const c = createClient()
+        c.start()
+        return c
+      })
     } else {
-      client = createClient()
+      const c = createClient()
 ${ls.verbose ? `      console.log('[${escapeStr(id)}] starting client')\n` : ''}\
-      client.start()
+      c.start()
+      clients = [c]
     }
 
     context.subscriptions.push(
       commands.registerCommand('${escapeStr(pluginName)}.restart', async () => {
-        await client.stop()
-        await client.start()
+        for (const c of clients) {
+          await c.stop()
+          await c.start()
+        }
       }),
     )
   } catch (e: any) {

package/converter/src/steps/snippets.ts

@@ -1,5 +1,6 @@
 import * as fs from 'fs'
 import * as path from 'path'
+import { execFileSync } from 'child_process'
 import { StepGenerator, StepContext, SnippetsStep, StepResult } from '../types.js'
 
 export const snippetsGenerator: StepGenerator = {
@@ -71,6 +72,26 @@ export const snippetsGenerator: StepGenerator = {
       if (verbose) console.log(`  snippets: copied ${sourceRelPath} (${languages.join(', ')})`)
     }
 
+    if (copiedCount === 0 && ss.build) {
+      // Run build script to generate snippet files (e.g. node merge.js)
+      if (verbose) console.log(`  snippets: running build: ${ss.build}`)
+      execFileSync('npm', ['install', '--legacy-peer-deps'], { cwd: input, stdio: verbose ? 'inherit' : 'pipe' })
+      const [cmd, ...args] = ss.build.split(' ')
+      execFileSync(cmd, args, { cwd: input, stdio: verbose ? 'inherit' : 'pipe' })
+      // Retry copying
+      for (const [sourceRelPath, languages] of fileToLanguages) {
+        const sourceFile = path.join(input, sourceRelPath)
+        if (fs.existsSync(sourceFile)) {
+          const dest = path.join(output, sourceRelPath)
+          fs.mkdirSync(path.dirname(dest), { recursive: true })
+          fs.copyFileSync(sourceFile, dest)
+          copiedCount++
+          allLanguages.push(...languages)
+          if (verbose) console.log(`  snippets: copied ${sourceRelPath} (${languages.join(', ')})`)
+        }
+      }
+    }
+
     if (copiedCount === 0) {
       throw new Error('snippets step: no snippet files were copied')
     }

package/converter/src/transforms/class-to-factory.ts

@@ -20,16 +20,14 @@ export const transformClassToFactory: Transform = (ctx) => {
 
   // AST approach: try to replace via ts-morph
   const nodes = file.getDescendantsOfKind(SyntaxKind.NewExpression)
-  const astReplacements: Array<{ node: any, text: string }> = []
+  // Sort by position descending so inner nodes are processed first
+  nodes.sort((a, b) => b.getPos() - a.getPos())
   for (const expr of nodes) {
     const text = expr.getText()
     const m = text.match(/^new\s+(\w+)\(/)
     if (!m || !FACTORY_TYPES.has(m[1])) continue
     const args = text.slice(m[0].length, -1)
-    astReplacements.push({ node: expr, text: `${m[1]}.create(${args})` })
-  }
-  for (const { node, text } of astReplacements) {
-    try { node.replaceWithText(text) } catch {}
+    try { expr.replaceWithText(`${m[1]}.create(${args})`) } catch {}
   }
 
   // Text fallback: catch remaining new Xxx() that AST might have missed

package/converter/src/transforms/provider-register.ts

@@ -44,14 +44,36 @@ export const transformProviderRegister: Transform = (ctx) => {
       `registerCompletionItemProvider('${pluginName}', '${shortcut}', `
     )
     // Wrap the last argument in an array if it's a string (trigger chars)
-    content = content.replace(
-      /(registerCompletionItemProvider\([^)]+),\s*'([^']+)'\)/g,
-      '$1, ["$2"])'
-    )
-    content = content.replace(
-      /(registerCompletionItemProvider\([^)]+),\s*"([^"]+)"\)/g,
-      '$1, ["$2"])'
-    )
+    // Use paren-balancing to handle nested parentheses in arguments
+    // Build result by iterating over all matches, replacing each full call
+    const providerRe = /registerCompletionItemProvider\(/g
+    let result = ''
+    let lastIdx = 0
+    let m: RegExpExecArray | null
+    while ((m = providerRe.exec(content)) !== null) {
+      const start = m.index
+      let depth = 1
+      let i = start + m[0].length
+      while (i < content.length && depth > 0) {
+        if (content[i] === '(') depth++
+        else if (content[i] === ')') depth--
+        i++
+      }
+      const end = i
+      const fullCall = content.slice(start, end)
+      const lastStrMatch = fullCall.match(/,?\s*'([^']+)'\s*\)$/)
+      const lastDblMatch = fullCall.match(/,?\s*"([^"]+)"\s*\)$/)
+      let replacement = fullCall
+      if (lastStrMatch) {
+        replacement = fullCall.slice(0, fullCall.length - lastStrMatch[0].length) + ', ["' + lastStrMatch[1] + '"])'
+      } else if (lastDblMatch) {
+        replacement = fullCall.slice(0, fullCall.length - lastDblMatch[0].length) + ', ["' + lastDblMatch[1] + '"])'
+      }
+      result += content.slice(lastIdx, start) + replacement
+      lastIdx = end
+    }
+    result += content.slice(lastIdx)
+    content = result
     changed = true
   }
 

package/converter/src/types.ts

@@ -77,6 +77,8 @@ export interface SnippetsStep {
   type: 'snippets'
   /** Optional: override languages to generate (default: read from source package.json's contributes.snippets) */
   languages?: string[]
+  /** Optional: build command to run in source dir before collecting snippet files (e.g. "node merge.js") */
+  build?: string
 }
 
 export type ConvertStep = LanguageClientStep | SourceStep | BridgeStep | MarkUnsupportedStep | SnippetsStep

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.6",
+      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) => {
+    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,13 +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();
+  }
 }
-var PAGE_SIZE = 50;
 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;
@@ -269,17 +302,22 @@ function createInitialState() {
       marked: false
     };
   });
-  return { packages, searchQuery: "", showHelp: false, activePill: null, dirty: false, viewFilter: "all", sortBy: "default", currentPage: 0 };
+  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);
@@ -299,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;
@@ -340,25 +382,25 @@ var StateManager = class {
   setViewFilter(filter) {
     this.mutate((s) => {
       s.viewFilter = filter;
-      s.currentPage = 0;
+      s.scrollOffset = 0;
     });
   }
   cycleViewFilter() {
     this.mutate((s) => {
       s.viewFilter = s.viewFilter === "all" ? "installed" : s.viewFilter === "installed" ? "not-installed" : "all";
-      s.currentPage = 0;
+      s.scrollOffset = 0;
     });
   }
   setSortBy(sortBy) {
     this.mutate((s) => {
       s.sortBy = sortBy;
-      s.currentPage = 0;
+      s.scrollOffset = 0;
     });
   }
   cycleSortBy() {
     this.mutate((s) => {
       s.sortBy = s.sortBy === "default" ? "name" : s.sortBy === "name" ? "status" : s.sortBy === "status" ? "type" : "default";
-      s.currentPage = 0;
+      s.scrollOffset = 0;
     });
   }
   setStatusMessage(msg) {
@@ -379,15 +421,19 @@ var StateManager = class {
   setSearchQuery(query) {
     this.mutate((s) => {
       s.searchQuery = query;
-      s.currentPage = 0;
+      s.scrollOffset = 0;
     });
   }
-  setPage(n) {
+  setScrollOffset(n) {
     this.mutate((s) => {
-      s.currentPage = n;
+      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");
@@ -409,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) {
@@ -429,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]));
@@ -440,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,
@@ -522,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);
@@ -593,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 = [
@@ -744,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");
@@ -770,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);
@@ -849,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);
@@ -909,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;
   }
 }
 
@@ -973,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 = "";
@@ -1039,11 +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",
-  "    [/]        Previous/next page",
+  "    j/k        Scroll through packages",
+  "    /          Search filter (then j/k to scroll)",
   "    gg         Jump to first page",
   "    G          Jump to last page",
-  "    <Enter>    Toggle expand/collapse details",
-  "    /          Search filter",
+  "    <Enter>    Open detail popup (description, source, log)",
   "    q          Close window",
   "    <Esc>      Help\u2192Search\u2192Marks\u2192Busy guard\u2192Close",
   "",
@@ -1054,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;
@@ -1063,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",
@@ -1080,16 +1169,20 @@ var TUI = class {
       x: "x",
       D: "D",
       gg: "gg",
-      G: "G",
-      "[": "pageup",
-      "]": "pagedown"
+      G: "G"
     };
     this.rendering = false;
     this.pendingRender = false;
-    this.lastPage = -1;
-    this.scrollToFirst = 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");
@@ -1107,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, {
@@ -1116,7 +1211,7 @@ var TUI = class {
       height,
       row,
       col,
-      border: "none",
+      border: "rounded",
       style: "minimal"
     });
     this.winid = win.id;
@@ -1147,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();
           }
         }
       })
@@ -1162,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(() => {
@@ -1176,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") {
@@ -1211,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") {
@@ -1228,36 +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") {
-      this.state.setPage(0);
-      this.scrollToFirst = true;
+      this.state.setScrollOffset(0);
+      this.focusIndex = 0;
       return;
     }
     if (id === "G") {
       const filtered = this.state.getFilteredPackages();
-      const totalPages = Math.ceil(filtered.length / PAGE_SIZE) || 1;
-      this.state.setPage(totalPages - 1);
+      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 === "pagedown") {
+    if (id === "j") {
       const filtered = this.state.getFilteredPackages();
-      const totalPages = Math.ceil(filtered.length / PAGE_SIZE) || 1;
-      const s2 = this.state.getState();
-      if (s2.currentPage < totalPages - 1) {
-        this.state.setPage(s2.currentPage + 1);
+      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 === "pageup") {
-      const s2 = this.state.getState();
-      if (s2.currentPage > 0) {
-        this.state.setPage(s2.currentPage - 1);
+    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;
     }
@@ -1323,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;
     }
   }
@@ -1352,10 +1487,10 @@ var TUI = class {
       ["s", "s"],
       ["x", "x"],
       ["D", "D"],
+      ["j", "j"],
+      ["k", "k"],
       ["gg", "gg"],
       ["G", "G"],
-      ["[", "pageup"],
-      ["]", "pagedown"],
       ["<CR>", "cr"]
     ];
     for (const [vimKey, id] of entries) {
@@ -1372,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]);
@@ -1396,26 +1538,47 @@ 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(() => {
+        });
       }
-      await nvim.resumeNotification();
-      const shouldScroll = this.scrollToFirst || state.currentPage !== this.lastPage;
-      this.scrollToFirst = false;
-      this.lastPage = state.currentPage;
-      if (!state.showHelp && shouldScroll) {
-        const firstPkgLine = Math.min(...result.pkgLineMap.keys());
-        if (isFinite(firstPkgLine)) {
-          await nvim.call("nvim_win_set_cursor", [this.winid, [firstPkgLine + 1, 0]]);
+      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]]);
+          }
         }
       }
       this.pkgLineMap = result.pkgLineMap;
@@ -1483,19 +1646,16 @@ var TUI = class {
     }
     buf.nl();
     buf.nl();
-    const totalPages = Math.ceil(filtered.length / PAGE_SIZE) || 1;
-    const page = Math.min(state.currentPage, totalPages - 1);
-    const start = page * PAGE_SIZE;
-    const pageItems = filtered.slice(start, start + PAGE_SIZE);
-    const end = Math.min(start + PAGE_SIZE, filtered.length);
-    if (totalPages > 1) {
-      buf.append(`Page ${page + 1}/${totalPages} \xB7 ${start + 1}\u2013${end} of ${filtered.length}`, "CocConverterTotal");
-    } else {
-      buf.append(`${filtered.length} packages`, "CocConverterTotal");
-    }
+    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 pageItems) {
+    for (const e of visible) {
       this.renderEntry(buf, pkgLineMap, logSet, e);
     }
     if (filtered.length === 0 && state.searchQuery) {
@@ -1504,12 +1664,13 @@ var TUI = class {
     buf.nl();
     buf.append(" " + "\u2500".repeat(50), "Comment");
     buf.nl();
-    const pageNav = totalPages > 1 ? `  [  prev  ] next` : "";
-    buf.append(` ${filtered.length} packages \xB7 ${filterLabel} \xB7 ${sortLabel}${pageNav}`, "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();
@@ -1523,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;
@@ -1641,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(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "coc-vscode-loader",
-  "version": "1.2.6",
+  "version": "1.2.7",
   "description": "Run VS Code extensions seamlessly in coc.nvim",
   "main": "lib/index.js",
   "keywords": [