coc-vscode-loader 1.2.1 → 1.2.3

package/converter/package.json

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

package/converter/src/convert.ts

@@ -68,7 +68,9 @@ export async function convert(opts: ConvertOptions): Promise<void> {
   }
   console.log(result.summary)
 
-  if (result.files.length === 0) {
+  // Source-only steps need source files; bridge/language-client steps can generate code
+  const hasNonSourceStep = steps.some(s => s.type !== 'source' && s.type !== 'mark-unsupported')
+  if (result.files.length === 0 && !hasNonSourceStep) {
     console.log('No VS Code API usage found, nothing to convert.')
     return
   }
@@ -174,7 +176,7 @@ export async function convert(opts: ConvertOptions): Promise<void> {
     if (fs.existsSync(outputSrc)) {
       for (const f of fs.readdirSync(outputSrc, { recursive: true })) {
         const fp = typeof f === 'string' ? path.join(outputSrc, f) : f
-        if (!fp.endsWith('.ts')) continue
+        if (!fp.endsWith('.ts') && !fp.endsWith('.js')) continue
         let content = fs.readFileSync(fp, 'utf-8')
         let changed = false
 
@@ -198,13 +200,38 @@ export async function convert(opts: ConvertOptions): Promise<void> {
         }
 
         if (content.includes('.fileName') || content.includes('.uri.fsPath')) {
-          // .fileName → .uri (coc's TextDocument#uri returns a string path, not a URI object)
-          content = content.replace(/(document|this\.document|textDocument|scope)\.fileName/g, '$1.uri')
-          // .uri.fsPath → .uri (coc's uri is already a string path, not a URI object)
-          content = content.replace(/\.uri\.fsPath/g, '.uri')
+          // .fileName → Uri.parse($1.uri).fsPath (coc's TextDocument#uri returns a file:// URI string)
+          content = content.replace(/(document|this\.document|textDocument|scope|doc)\.fileName/g, 'Uri.parse($1.uri).fsPath')
+          // Handle destructuring: const { fileName, ...rest } = document/doc/textDocument
+          content = content.replace(
+            /^(\s*)(const|let|var)\s*\{([^}]*)\}\s*=\s*(document|doc|textDocument)\s*;?\s*$/gm,
+            (m: string, indent: string, kw: string, props: string, varName: string) => {
+              const parts = props.split(',').map((p: string) => p.trim())
+              if (!parts.some((p: string) => p === 'fileName')) return m
+              const rest = parts.filter((p: string) => p !== 'fileName' && p !== '')
+              return rest.length > 0
+                ? `${indent}${kw} {${rest.join(', ')}} = ${varName};\n${indent}const fileName = Uri.parse(${varName}.uri).fsPath`
+                : `${indent}const fileName = Uri.parse(${varName}.uri).fsPath`
+            }
+          )
+          // .uri.fsPath → Uri.parse(...).fsPath (coc's uri is a file:// URI string, not a path)
+          content = content.replace(/(\w+(?:\.\w+)*?)\.uri\.fsPath/g, 'Uri.parse($1.uri).fsPath')
           changed = true
         }
 
+        // Ensure Uri is imported when introduced by Uri.parse() replacements
+        if (content.includes('Uri.parse(') && content.match(/from\s+['"]coc\.nvim['"]/)) {
+          content = content.replace(
+            /(import\s*\{\s*)([^}]*?)(\s*\}\s*from\s*['"]coc\.nvim['"])/g,
+            (_m: string, prefix: string, existing: string, suffix: string) => {
+              if (!existing.includes('Uri')) {
+                const sep = existing.trim() ? ', ' : ''
+                return `${prefix}${existing.trim()}${sep}Uri${suffix}`
+              }
+              return _m
+            }
+          )
+        }
         if (changed) fs.writeFileSync(fp, content)
       }
     }

package/converter/src/steps/bridge.ts

@@ -72,7 +72,32 @@ export const bridgeGenerator: StepGenerator = {
 ${code}`
     }
 
-    // Generate the bridge module
+    const extIds = generated.injectExts || []
+    const svcIds = generated.injectSvcs || []
+    const callAfter = generated.callAfter
+    const isStandalone = !callAfter && extIds.length === 0 && svcIds.length === 0
+
+    if (isStandalone) {
+      // Standalone preset (e.g. prettier): generate entry point directly
+      const moduleContent = `\
+import { ExtensionContext, languages, Range, TextEdit, Uri, window, workspace } from 'coc.nvim'
+
+export async function activate(context: ExtensionContext): Promise<void> {
+${code}
+}
+`
+      return {
+        generatedFiles: [{ path: 'src/index.ts', content: moduleContent }],
+        entryPoint: 'src/index.ts',
+        keepDeps: Object.fromEntries((generated.extraDeps || []).map((d: string) => {
+          const ver = ctx.origPkg.dependencies?.[d] || ctx.origPkg.devDependencies?.[d]
+          return [d, ver || '*']
+        })),
+        activationEvents: ['*'],
+      }
+    }
+
+    // Generate the bridge module (for tsserver-forward etc)
     const moduleContent = `\
 import { commands, ExtensionContext } from 'coc.nvim'
 
@@ -83,9 +108,6 @@ ${code}
 
     // Build code injections
     const codeInjections: StepResult['codeInjections'] = []
-    const extIds = generated.injectExts || []
-    const svcIds = generated.injectSvcs || []
-    const callAfter = generated.callAfter
 
     if (callAfter) {
       codeInjections.push({

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

@@ -42,21 +42,30 @@ export const languageClientGenerator: StepGenerator = {
       const entry = ls.server.entry || 'main'
 
       // Same resolution as old converter: resolve main entry first, then walk for bin
+      // Use require.resolve('pkg/package.json') as fallback for packages without main entry
+      const binName = ls.server.binName || ''
+      const binLookupCode = binName
+        ? `(_pkg.bin && _pkg.bin['${escapeStr(binName)}'] ? _pkg.bin['${escapeStr(binName)}'] : Object.values(_pkg.bin)[0])`
+        : `(typeof _pkg.bin === 'string' ? _pkg.bin : Object.values(_pkg.bin)[0])`
       serverPathCode = `\
     let serverPath: string | undefined
+    let _mainEntry: string | undefined
     try {
-      serverPath = require.resolve('${escapeStr(pkg)}')
+      _mainEntry = require.resolve('${escapeStr(pkg)}')
     } catch {}
+    if (!_mainEntry) {
+      try { _mainEntry = require.resolve('${escapeStr(pkg)}/package.json') } catch {}
+    }
     try {
       // Walk up from the resolved main entry to find the package's package.json
       // We can't use require.resolve('pkg/package.json') because exports field may block it
-      let _dir = require('path').dirname(require.resolve('${escapeStr(pkg)}'));
-      while (_dir !== require('path').dirname(_dir)) {
+      let _dir = _mainEntry ? require('path').dirname(_mainEntry) : undefined;
+      while (_dir && _dir !== require('path').dirname(_dir)) {
         const _pkgPath = require('path').join(_dir, 'package.json');
         if (require('fs').existsSync(_pkgPath)) {
           const _pkg = JSON.parse(require('fs').readFileSync(_pkgPath, 'utf-8'));
           if (_pkg.bin) {
-            const _entry = typeof _pkg.bin === 'string' ? _pkg.bin : Object.values(_pkg.bin)[0];
+            const _entry = ${binLookupCode};
             serverPath = require('path').join(_dir, _entry);
           }
           break;
@@ -65,7 +74,7 @@ export const languageClientGenerator: StepGenerator = {
       }
     } catch {}`
       // Use full require.resolve path (including bin walking) if available, else fallback to simple main entry
-      serverOptionsCode = `{ module: serverPath || require.resolve('${escapeStr(pkg)}'), transport: ${transportExpr} }`
+      serverOptionsCode = `{ module: serverPath || _mainEntry || require.resolve('${escapeStr(pkg)}/package.json'), transport: ${transportExpr} }`
     }
 
     const docSelectorCode = `[${languages.map(l => `{ scheme: 'file', language: '${l}' }`).join(', ')}]`
@@ -99,6 +108,7 @@ ${ls.verbose ? `    console.log('[${escapeStr(id)}] creating LanguageClient')\n`
         {
           documentSelector: ${docSelectorCode},
           outputChannelName: '${escapeStr(description)}',
+          ${ls.initializationOptions ? `initializationOptions: ${ls.initializationOptions},` : ''}
         },
       )
       context.subscriptions.push({ dispose: () => c.stop() })

package/converter/src/steps/source.ts

@@ -39,18 +39,19 @@ export const sourceGenerator: StepGenerator = {
     const outputsDir = path.join(output, 'src')
     fs.mkdirSync(outputsDir, { recursive: true })
 
-    // Copy ALL .ts/.tsx files from source directory (try src/ first, fall back to input root)
+    // Copy ALL .ts/.tsx/.js files from source directory (try src/ first, fall back to input root)
     let srcDir = path.join(input, 'src')
     if (!fs.existsSync(srcDir)) {
       srcDir = input
     }
     const hasStripVolar = ss.transforms.includes('strip-volar')
     const allFiles: Array<{ src: string; rel: string }> = []
+    const jsFiles: string[] = []
     const vscodeFiles: string[] = []
 
     for (const f of walkFiles(srcDir)) {
       const rel = path.relative(srcDir, f)
-      if (!rel.endsWith('.ts') && !rel.endsWith('.tsx')) continue
+      if (!rel.endsWith('.ts') && !rel.endsWith('.tsx') && !rel.endsWith('.js')) continue
 
       // Skip framework files that are replaced by generated code
       if (hasStripVolar) {
@@ -61,8 +62,10 @@ export const sourceGenerator: StepGenerator = {
       allFiles.push({ src: f, rel })
 
       const content = fs.readFileSync(f, 'utf-8')
-      if (content.includes("from 'vscode'") || content.includes('from "vscode"') || content.includes('require("vscode")')) {
+      const hasVscode = content.includes("from 'vscode'") || content.includes('from "vscode"') || content.includes('require("vscode")')
+      if (hasVscode) {
         vscodeFiles.push(rel)
+        if (rel.endsWith('.js')) jsFiles.push(rel)
       }
     }
 
@@ -74,13 +77,13 @@ export const sourceGenerator: StepGenerator = {
     }
 
     if (verbose) {
-      console.log(`  source: copied ${allFiles.length} files (${vscodeFiles.length} with vscode imports)`)
+      console.log(`  source: copied ${allFiles.length} files (${vscodeFiles.length} with vscode imports, ${jsFiles.length} .js)`)
     }
 
-    // Apply transforms via ts-morph (only to files with vscode imports)
+    // Apply transforms via ts-morph (only to TS files with vscode imports; .js files get text-level only)
     for (const rel of vscodeFiles) {
       const fp = path.join(outputsDir, rel)
-      if (!fs.existsSync(fp)) continue
+      if (!fs.existsSync(fp) || rel.endsWith('.js')) continue
       try { project.addSourceFileAtPath(fp) } catch {}
     }
 
@@ -104,6 +107,36 @@ export const sourceGenerator: StepGenerator = {
       sf.saveSync()
     }
 
+    // Apply text-level replacements to .js files (ts-morph can't handle JS)
+    for (const rel of jsFiles) {
+      const fp = path.join(outputsDir, rel)
+      if (!fs.existsSync(fp)) continue
+      let code = fs.readFileSync(fp, 'utf-8')
+      const orig = code
+      code = code.replace(/require\(['"]vscode['"]\)/g, "require('coc.nvim')")
+      code = code.replace(/(\w+)\.fileName\b/g, "Uri.parse($1.uri).fsPath")
+      code = code.replace(/(\w+(?:\.\w+)*?)\.uri\.fsPath/g, 'Uri.parse($1.uri).fsPath')
+      if (code.includes('window.activeTextEditor')) {
+        code = `\
+if (typeof window !== 'undefined' && !('activeTextEditor' in window)) {
+  try {
+    Object.defineProperty(window, 'activeTextEditor', {
+      get() {
+        try {
+          var doc = typeof workspace !== 'undefined' ? workspace.getDocument() : undefined;
+          return doc ? { document: doc } : undefined;
+        } catch(e) { return undefined }
+      },
+      configurable: true,
+    });
+  } catch {}
+}
+` + code
+      }
+      code = code.replace(/window\.onDidChangeActiveTextEditor/g, 'workspace.onDidOpenTextDocument')
+      if (code !== orig) fs.writeFileSync(fp, code)
+    }
+
     // Resolve keepDeps from origPkg (with workspace root fallback)
     const keepDeps: Record<string, string> = {}
     if (ss.keepDeps) {

package/converter/src/transforms/import-mapping.ts

@@ -5,12 +5,12 @@ import { Transform } from '../types.js'
  * and apply name remapping for known API differences.
  */
 const MAPPINGS: Record<string, string> = {
-  // namespace
-  'vscode': 'coc.nvim',
+  // namespace (module specifier is rewritten by AST, keep identifier as-is)
 
   // naming differences
   'EventEmitter': 'Emitter',
   'Disposable': 'Disposable',
+  'StatusBarAlignment': '(void 0) as any',
 
   // function/method renames
   'getExtension': 'getExtensionById',
@@ -25,23 +25,169 @@ export const transformImportMapping: Transform = (ctx) => {
   const { file } = ctx
 
   // Rewrite import declarations
-  file.getImportDeclarations().forEach(decl => {
-    const mod = decl.getModuleSpecifierValue()
-    if (mod === 'vscode') {
-      decl.setModuleSpecifier('coc.nvim')
-    }
-  })
+  try {
+    file.getImportDeclarations().forEach(decl => {
+      const mod = decl.getModuleSpecifierValue()
+      if (mod === 'vscode') {
+        decl.setModuleSpecifier('coc.nvim')
+      }
+    })
+  } catch {}
 
   // Rewrite named references
-  file.getDescendantsOfKind(192 /* Identifier */).forEach(node => {
-    const text = node.getText()
-    const mapped = MAPPINGS[text]
-    if (mapped && mapped !== text) {
-      // Only replace if it's a direct reference, not part of a string
-      const parent = node.getParent()
-      if (parent && parent.getKindName() !== 'StringLiteral') {
-        node.replaceWithText(mapped)
+  try {
+    file.getDescendantsOfKind(80 /* Identifier */).forEach(node => {
+      const text = node.getText()
+      if (Object.prototype.hasOwnProperty.call(MAPPINGS, text)) {
+        const mapped = MAPPINGS[text]
+        if (mapped !== text) {
+          const parent = node.getParent()
+          if (parent && parent.getKindName() !== 'StringLiteral') {
+            node.replaceWithText(mapped)
+          }
+        }
+      }
+    })
+  } catch {}
+
+  // Replace CodeActionKind.SourceFixAll.append('xxx') with string literal
+  try {
+    file.getDescendantsOfKind(214 /* CallExpression */).forEach(node => {
+      const text = node.getText()
+      const match = text.match(/^CodeActionKind\.SourceFixAll\.append\(['"](.+)['"]\)$/)
+      if (match) {
+        node.replaceWithText(`'source.fixAll.${match[1]}'`)
+      }
+    })
+  } catch {}
+
+  // Text-level replacements for coc.nvim API differences
+
+  // Convert require('vscode') to require('coc.nvim') (JS-style imports)
+  let content = file.getText()
+  let newContent = content.replace(
+    /require\(['"]vscode['"]\)/g,
+    "require('coc.nvim')",
+  )
+
+  // Convert dynamic import() to require()
+  newContent = newContent.replace(
+    /await\s+import\(/g,
+    'require(',
+  )
+
+  // Convert createStatusBarItem(name, alignment, priority) → createStatusBarItem(priority)
+  newContent = newContent.replace(
+    /createStatusBarItem\([^,]+,\s*(?:\w+\.)?(?:Right|Left),\s*/g,
+    'createStatusBarItem(',
+  )
+
+  // Replace LanguageStatusSeverity.xxx → 2
+  newContent = newContent.replace(
+    /LanguageStatusSeverity\.\w+/g,
+    '2',
+  )
+
+  // Replace StatusBar with a no-op mock so formatting works without status UI
+  newContent = newContent.replace(
+    /new\s+StatusBar\(\)/g,
+    'new (class { update(){} hide(){} updateConfig(){} dispose(){} } as any)()',
+  )
+
+  // Treat all workspaces as trusted (coc.nvim doesn't have workspace.isTrusted)
+  newContent = newContent.replace(
+    /workspace\.isTrusted/g,
+    'true',
+  )
+
+  // Wrap new CodeAction() in try-catch (coc.nvim may not have CodeAction)
+  newContent = newContent.replace(
+    /const action = new CodeAction\(/g,
+    'let action; try { action = new CodeAction(',
+  )
+  // Close the try-catch before return [action]
+  newContent = newContent.replace(
+    /return \[action\];/g,
+    '}catch(e){action={title:"",kind:""}};return [action];',
+  )
+
+  // window.createOutputChannel works in coc.nvim (workspace variant is deprecated)
+  // no replacement needed
+
+  // Polyfill window.activeTextEditor (VS Code API, not in coc.nvim)
+  if (newContent.includes('window.activeTextEditor')) {
+    newContent = `\
+if (typeof window !== 'undefined' && !('activeTextEditor' in window)) {
+  try {
+    Object.defineProperty(window, 'activeTextEditor', {
+      get() {
+        try {
+          var doc = typeof workspace !== 'undefined' ? workspace.getDocument() : undefined;
+          return doc ? { document: doc } : undefined;
+        } catch(e) { return undefined }
+      },
+      configurable: true,
+    });
+  } catch {}
+}
+` + newContent
+  }
+
+  // window.onDidChangeActiveTextEditor → workspace.onDidOpenTextDocument
+  newContent = newContent.replace(/window\.onDidChangeActiveTextEditor/g, 'workspace.onDidOpenTextDocument')
+
+  // languages.createLanguageStatusItem → no-op (coc.nvim doesn't have this)
+  newContent = newContent.replace(
+    /languages\.createLanguageStatusItem\([^)]+\)/g,
+    '({ dispose(){}, text: "", command: void 0, name: "", accessibilityInformation: void 0, severity: void 0 }) as any'
+  )
+
+  // window.showOpenDialog → not available in coc, return undefined
+  newContent = newContent.replace(
+    /window\.showOpenDialog\([^)]*\)/g,
+    'void 0 as any'
+  )
+
+  // Add priority 1 to document format providers (default 0 gets overridden by LanguageClient)
+  newContent = newContent.replace(
+    /registerDocumentFormatProvider\s*\(\s*(\w[\w.]*)\s*,\s*(\w[\w.]*)\s*,?\s*\)/g,
+    'registerDocumentFormatProvider($1, $2, 1)'
+  )
+  newContent = newContent.replace(
+    /registerDocumentRangeFormatProvider\s*\(\s*(\w[\w.]*)\s*,\s*(\w[\w.]*)\s*,?\s*\)/g,
+    'registerDocumentRangeFormatProvider($1, $2, 1)'
+  )
+
+  // authentication.getSession → undefined (coc.nvim has no auth API)
+  newContent = newContent.replace(
+    /authentication\.getSession\s*\([^)]*\)/g,
+    'undefined as any'
+  )
+
+  // editor.setDecorations → no-op (coc has different decoration API)
+  newContent = newContent.replace(/editor\.setDecorations\s*\([^)]+\)/g, '/* setDecorations */')
+
+  // Guard workspace.workspaceFolders when accessed via index (coc.nvim may return undefined)
+  newContent = newContent.replace(
+    /workspace\.workspaceFolders(?=\[)/g,
+    '(workspace.workspaceFolders || [])'
+  )
+
+  // Ensure workspace is imported from coc.nvim when we introduced workspace. references
+  if (newContent.includes('workspace.') && newContent.match(/from\s+['"]coc\.nvim['"]/)) {
+    newContent = newContent.replace(
+      /(import\s*\{\s*)([^}]*?)(\s*\}\s*from\s*['"]coc\.nvim['"])/g,
+      (match, prefix, existing, suffix) => {
+        if (!existing.includes('workspace')) {
+          const sep = existing.trim() ? ', ' : ''
+          return `${prefix}${existing.trim()}${sep}workspace${suffix}`
+        }
+        return match
       }
-    }
-  })
+    )
+  }
+
+  if (newContent !== content) {
+    file.replaceWithText(newContent)
+  }
 }

package/converter/src/types.ts

@@ -13,6 +13,9 @@ export interface ServerModuleConfig {
   kind: 'module'
   package: string
   entry?: 'main' | 'bin'
+  /** When entry is 'bin', pick a specific bin entry by name (e.g. "tailwindcss-language-server").
+   *  Defaults to the first entry in the bin object. */
+  binName?: string
 }
 
 export interface ServerBinaryConfig {
@@ -37,6 +40,8 @@ export interface LanguageClientStep {
   multiRoot?: boolean
   /** Enable debug logging in generated code */
   verbose?: boolean
+  /** Extra options passed as initializationOptions to LanguageClient (JS object expression, inserted as-is) */
+  initializationOptions?: string
 }
 
 export interface SourceStep {

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.1",
+      version: "1.2.3",
       description: "Run VS Code extensions seamlessly in coc.nvim",
       main: "lib/index.js",
       keywords: [
@@ -89,13 +89,34 @@ var require_package = __commonJS({
       ],
       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: "" }
+          {
+            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: ""
+          }
         ]
       }
     };
@@ -500,7 +521,7 @@ async function downloadSource(info, name, onProgress) {
 }
 async function convertSource(inputDir, name, info, onProgress) {
   const build = buildDir(name);
-  if (fs3.existsSync(build)) fs3.rmSync(build, { recursive: true });
+  await rimraf(build);
   const cli = converterCliPath();
   const converterDir = path3.resolve(path3.dirname(path3.dirname(cli)));
   if (!fs3.existsSync(path3.join(converterDir, "node_modules", "commander"))) {
@@ -593,34 +614,53 @@ async function buildPackage(name, inputDir, info, onProgress) {
     onProgress(3, 5, "Installing server dependencies...", `npm install in ${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 });
+    await rimraf(destServer);
+    await cpdir(serverDir, destServer);
   }
   onProgress(4, 5, "Building...", "node esbuild.mjs");
   const buildLog = (chunk) => onProgress(4, 5, chunk.trim(), "");
   await run("node", ["esbuild.mjs"], build, buildLog);
+  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 rawArch = archMap[arch2] || arch2;
+  const rustTarget = `${rawArch}-${platformMap[platform] || platform}`;
+  const indexPath = path3.join(build, "lib", "index.js");
+  if (fs3.existsSync(indexPath)) {
+    let code = fs3.readFileSync(indexPath, "utf-8");
+    for (const [key, val] of [["platform", platform], ["arch", arch2], ["raw-arch", rawArch], ["rust-target", rustTarget]]) {
+      code = code.replace(new RegExp(`\\{\\{${key}}}`, "g"), val);
+    }
+    if (code !== fs3.readFileSync(indexPath, "utf-8")) {
+      fs3.writeFileSync(indexPath, code);
+    }
+  }
   if (info.serverBinary) {
     const sb = info.serverBinary;
     onProgress(4, 5, "Downloading language server...", `fetching ${sb.repo}`);
     try {
-      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();
+      let tagData;
+      try {
+        const tagRes = await fetch(`https://api.github.com/repos/${sb.repo}/releases/latest`);
+        if (!tagRes.ok) throw new Error(`HTTP ${tagRes.status}`);
+        tagData = await tagRes.json();
+      } catch {
+        const { execFile: execFile2 } = require("child_process");
+        const out = await new Promise((resolve2, reject) => {
+          execFile2("curl", ["-sL", `https://api.github.com/repos/${sb.repo}/releases/latest`], { encoding: "utf-8", maxBuffer: 1024 * 1024 }, (err, stdout) => err ? reject(err) : resolve2(stdout));
+        });
+        tagData = JSON.parse(out);
+      }
       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 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}`);
@@ -630,12 +670,15 @@ async function buildPackage(name, inputDir, info, onProgress) {
       fs3.mkdirSync(serverDir2, { recursive: true });
       if (filename.endsWith(".zip")) {
         await run("unzip", ["-o", filename, "-d", serverDir2], build);
+      } else if (filename.endsWith(".tar.gz") || filename.endsWith(".tgz")) {
+        await run("tar", ["xzf", filename, "-C", 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);
+        const binName = sb.binaryPath || filename;
+        fs3.renameSync(path3.join(build, filename), path3.join(serverDir2, binName));
       }
       try {
         fs3.readdirSync(serverDir2).forEach((f) => {
@@ -643,19 +686,18 @@ async function buildPackage(name, inputDir, info, onProgress) {
         });
       } catch {
       }
+      if (version) {
+        const verPath = path3.join(build, "lib", "index.js");
+        if (fs3.existsSync(verPath)) {
+          let vc = fs3.readFileSync(verPath, "utf-8");
+          if (vc.includes("{{version}}")) {
+            fs3.writeFileSync(verPath, vc.replace(/\{\{version}}/g, version));
+          }
+        }
+      }
       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)) {
-        let code = fs3.readFileSync(indexPath, "utf-8");
-        code = code.replace(/\{\{version}}/g, version);
-        code = code.replace(/\{\{platform}}/g, platform);
-        code = code.replace(/\{\{arch}}/g, arch2);
-        code = code.replace(/\{\{raw-arch}}/g, rawArch);
-        code = code.replace(/\{\{rust-target}}/g, rustTarget);
-        fs3.writeFileSync(indexPath, code);
+        if (fs3.existsSync(archivePath)) await rimraf(archivePath);
       }
     } catch (e) {
       onProgress(4, 5, `Warning: serverBinary setup failed (${e.message})`, "install server binary manually");
@@ -669,9 +711,9 @@ async function installToCoc(name, onProgress) {
   const src = buildDir(name);
   const dest = pluginDir(name);
   onProgress(5, 5, "Installing to coc...", `copy to ${dest} + register in extensions/package.json`);
-  if (fs3.existsSync(dest)) fs3.rmSync(dest, { recursive: true });
+  await rimraf(dest);
   fs3.mkdirSync(path3.dirname(dest), { recursive: true });
-  fs3.cpSync(src, dest, { recursive: true });
+  await cpdir(src, dest);
   const pkgPath = extensionsPkgPath();
   const pkg = fs3.existsSync(pkgPath) ? JSON.parse(fs3.readFileSync(pkgPath, "utf-8")) : { dependencies: {} };
   pkg.dependencies = pkg.dependencies || {};
@@ -737,13 +779,23 @@ async function installPackage(state, name) {
     state.setPackageStatus(name, "failed", { error: e.message });
   }
 }
+function rimraf(dir) {
+  return new Promise((resolve2, reject) => {
+    if (!fs3.existsSync(dir)) return resolve2();
+    (0, import_child_process2.spawn)("rm", ["-rf", dir], { stdio: "ignore" }).on("close", (code) => code === 0 ? resolve2() : reject(new Error(`rm -rf exited ${code}`)));
+  });
+}
+function cpdir(src, dest) {
+  return new Promise((resolve2, reject) => {
+    const parent = path3.dirname(dest);
+    if (!fs3.existsSync(parent)) fs3.mkdirSync(parent, { recursive: true });
+    (0, import_child_process2.spawn)("cp", ["-r", src, dest], { stdio: "ignore" }).on("close", (code) => code === 0 ? resolve2() : reject(new Error(`cp -r exited ${code}`)));
+  });
+}
 async function uninstallPackage(state, name) {
   state.setPackageStatus(name, "uninstalling", { progress: "[1/3] Removing from coc..." });
   try {
-    const dest = pluginDir(name);
-    if (fs3.existsSync(dest)) {
-      fs3.rmSync(dest, { recursive: true });
-    }
+    await rimraf(pluginDir(name));
     state.setPackageStatus(name, "uninstalling", { progress: "[2/3] Removing from package.json..." });
     const pkgPath = extensionsPkgPath();
     const pkg = JSON.parse(fs3.readFileSync(pkgPath, "utf-8"));
@@ -755,10 +807,7 @@ async function uninstallPackage(state, name) {
       fs3.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2));
     }
     state.setPackageStatus(name, "uninstalling", { progress: "[3/3] Removing cache..." });
-    const cache = cacheDir(name);
-    if (fs3.existsSync(cache)) {
-      fs3.rmSync(cache, { recursive: true });
-    }
+    await rimraf(cacheDir(name));
     state.setPackageStatus(name, "not-installed");
     state.setDirty();
     import_coc.window.showInformationMessage(`coc-${name} uninstalled`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "coc-vscode-loader",
-  "version": "1.2.1",
+  "version": "1.2.3",
   "description": "Run VS Code extensions seamlessly in coc.nvim",
   "main": "lib/index.js",
   "keywords": [
@@ -50,13 +50,34 @@
   ],
   "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": "" }
+      {
+        "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": ""
+      }
     ]
   }
 }