Merge branch 'dev' into toggle-comment-unformatted-partial-selection

Author: jramosg

CHANGELOG.md

@@ -6,6 +6,7 @@ Changes to Calva.
 
 - Fix: [Toggle comments off, indent glitch](https://github.com/BetterThanTomorrow/calva/issues/3078)
 - Fix: [Toggle Line Comment can break structure for unformatted partial multiline selections](https://github.com/BetterThanTomorrow/calva/issues/3083)
+- Fix: [Clojure-lsp not starting when offline](https://github.com/BetterThanTomorrow/calva/issues/1299)
 
 ## [2.0.555] - 2026-02-19
 

src/extension-test/unit/lsp/downloader-test.ts

@@ -0,0 +1,52 @@
+import * as expect from 'expect';
+import * as path from 'node:path';
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import { downloadWithBackupRecovery } from '../../../lsp/client/downloader-utils';
+
+describe('downloader', () => {
+  let tmpDir: string;
+  let binaryPath: string;
+  const binaryContent = 'existing-clojure-lsp-binary';
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'calva-downloader-test-'));
+    binaryPath = path.join(tmpDir, 'clojure-lsp');
+    fs.writeFileSync(binaryPath, binaryContent);
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it('replaces binary with new version on successful download', async () => {
+    const result = await downloadWithBackupRecovery(binaryPath, () => {
+      fs.writeFileSync(binaryPath, 'new-version');
+      return Promise.resolve();
+    });
+
+    expect(result.restored).toBe(false);
+    expect(fs.readFileSync(binaryPath, 'utf8')).toBe('new-version');
+    const backupPath = path.join(tmpDir, 'backup', 'clojure-lsp');
+    expect(fs.existsSync(backupPath)).toBe(false);
+  });
+
+  it('restores binary to original path after failed download so offline startup works', async () => {
+    await downloadWithBackupRecovery(binaryPath, () => {
+      return Promise.reject(new Error('network unavailable'));
+    });
+
+    expect(fs.existsSync(binaryPath)).toBe(true);
+    expect(fs.readFileSync(binaryPath, 'utf8')).toBe(binaryContent);
+  });
+
+  it('restores original binary even when download corrupts the file before failing', async () => {
+    await downloadWithBackupRecovery(binaryPath, () => {
+      fs.writeFileSync(binaryPath, 'corrupted-partial-download');
+      return Promise.reject(new Error('connection reset'));
+    });
+
+    expect(fs.existsSync(binaryPath)).toBe(true);
+    expect(fs.readFileSync(binaryPath, 'utf8')).toBe(binaryContent);
+  });
+});

src/lsp/client/downloader-utils.ts

@@ -0,0 +1,56 @@
+import * as path from 'node:path';
+import * as fs from 'node:fs';
+
+async function backupFile(filePath: string): Promise<string | null> {
+  const backupDir = path.join(path.dirname(filePath), 'backup');
+  const backupPath = path.join(backupDir, path.basename(filePath));
+
+  if (!fs.existsSync(filePath)) {
+    return null;
+  }
+
+  try {
+    await fs.promises.mkdir(backupDir, { recursive: true });
+    await fs.promises.rename(filePath, backupPath);
+    return backupPath;
+  } catch (e) {
+    console.log('Error while backing up existing file.', e.message);
+    return null;
+  }
+}
+
+async function restoreFile(backupPath: string, originalPath: string): Promise<boolean> {
+  try {
+    await fs.promises.rename(backupPath, originalPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export async function downloadWithBackupRecovery(
+  filePath: string,
+  download: () => Promise<void>
+): Promise<{
+  path: string;
+  restored: boolean;
+}> {
+  const backupPath = await backupFile(filePath);
+  try {
+    await download();
+    if (backupPath) {
+      await fs.promises.unlink(backupPath).catch((_) => undefined);
+    }
+    return { path: filePath, restored: false };
+  } catch (e) {
+    if (!backupPath) {
+      throw e;
+    }
+    console.log('Download failed, recovering from backup:', e.message);
+    const restored = await restoreFile(backupPath, filePath);
+    return {
+      path: restored ? filePath : backupPath,
+      restored: true,
+    };
+  }
+}

src/lsp/client/downloader.ts

@@ -5,6 +5,10 @@ import * as config from '../../config';
 import * as path from 'node:path';
 import * as vscode from 'vscode';
 import * as fs from 'node:fs';
+import { downloadWithBackupRecovery } from './downloader-utils';
+
+const VERSION_CHECK_TIMEOUT_MS = 10_000;
+const DOWNLOAD_TIMEOUT_MS = 120_000;
 
 const versionFileName = 'clojure-lsp-version';
 
@@ -56,39 +60,23 @@ export async function readVersionFile(extensionPath: string) {
 
 async function getLatestVersion(): Promise<string> {
   try {
-    const releasesJSON = await util.fetchFromUrl(
-      'https://api.github.com/repos/clojure-lsp/clojure-lsp/releases'
-    );
+    const releasesJSON = await Promise.race([
+      util.fetchFromUrl('https://api.github.com/repos/clojure-lsp/clojure-lsp/releases'),
+      new Promise<never>((_, reject) =>
+        setTimeout(() => reject(new Error('Version check timed out')), VERSION_CHECK_TIMEOUT_MS)
+      ),
+    ]);
     const releases = JSON.parse(releasesJSON);
     return releases[0].tag_name;
   } catch (err) {
     return '';
   }
 }
 
-async function backupExistingFile(clojureLspPath: string): Promise<string> {
-  const backupDir = path.join(path.dirname(clojureLspPath), 'backup');
-  const backupPath = path.join(backupDir, path.basename(clojureLspPath));
-
-  if (fs.existsSync(clojureLspPath)) {
-    try {
-      await fs.promises.mkdir(backupDir, {
-        recursive: true,
-      });
-      console.log('Backing up existing clojure-lsp to', backupPath);
-      await fs.promises.rename(clojureLspPath, backupPath);
-    } catch (e) {
-      console.log('Error while backing up existing clojure-lsp file.', e.message);
-    }
-  }
-
-  return fs.existsSync(backupPath) ? backupPath : null;
-}
-
 function downloadArtifact(url: string, filePath: string): Promise<void> {
   console.log('Downloading clojure-lsp from', url);
   return new Promise((resolve, reject) => {
-    https
+    const request = https
       .get(url, (response) => {
         if (response.statusCode === 200) {
           const writeStream = fs.createWriteStream(filePath);
@@ -100,11 +88,14 @@ function downloadArtifact(url: string, filePath: string): Promise<void> {
             })
             .pipe(writeStream);
         } else {
-          response.resume(); // Consume response to free up memory
+          response.resume();
           reject(new Error(response.statusMessage));
         }
       })
       .on('error', reject);
+    request.setTimeout(DOWNLOAD_TIMEOUT_MS, () => {
+      request.destroy(new Error('Download timed out'));
+    });
   });
 }
 
@@ -135,8 +126,8 @@ async function downloadClojureLsp(extensionPath: string, version: string): Promi
       : `https://github.com/clojure-lsp/clojure-lsp-dev-builds/releases/latest/download/${artifactName}`;
   const downloadPath = path.join(extensionPath, artifactName);
   const clojureLspPath = getClojureLspPath(extensionPath);
-  const backupPath = await backupExistingFile(clojureLspPath);
-  try {
+
+  const result = await downloadWithBackupRecovery(clojureLspPath, async () => {
     await downloadArtifact(url, downloadPath);
     if (path.extname(downloadPath) === '.zip') {
       await unzipFile(downloadPath, extensionPath);
@@ -145,19 +136,14 @@ async function downloadClojureLsp(extensionPath: string, version: string): Promi
       await fs.promises.chmod(clojureLspPath, 0o775);
     }
     writeVersionFile(extensionPath, version);
-  } catch (e) {
-    console.log(`Error downloading clojure-lsp, version: ${version}, from ${url}`, e);
-    if (backupPath) {
-      console.log('Using backup clojure-lsp');
-      void vscode.window.showWarningMessage(
-        `Error downloading clojure-lsp, version: ${version}, from ${url}. Using backup clojure-lsp`
-      );
-      return backupPath;
-    } else {
-      throw new Error(`Error downloading clojure-lsp, version: ${version}, from ${url}`);
-    }
+  });
+
+  if (result.restored) {
+    void vscode.window.showWarningMessage(
+      `Error downloading clojure-lsp, version: ${version}. Using previously downloaded clojure-lsp`
+    );
   }
-  return clojureLspPath;
+  return result.path;
 }
 
 export const ensureServerDownloaded = async (