Attempt to recover from corrupted updates.json file (#1505)

Signed-off-by: lujunsan <[email protected]>

Author: lujunsan

pkg/updates/checker.go

@@ -5,10 +5,12 @@ import (
 	"encoding/json"
 	"fmt"
 	"os"
+	"regexp"
 	"strings"
 	"time"
 
 	"github.com/adrg/xdg"
+	"github.com/gofrs/flock"
 	"github.com/google/uuid"
 	"golang.org/x/mod/semver"
 
@@ -47,7 +49,13 @@ func NewUpdateChecker(versionClient VersionClient) (UpdateChecker, error) {
 		var contents updateFile
 		err = json.Unmarshal(rawContents, &contents)
 		if err != nil {
-			return nil, fmt.Errorf("failed to deserialize update file: %w", err)
+			// If the file is corrupted, attempt to recover
+			if recoveredFile, recoverErr := recoverCorruptedJSON(rawContents); recoverErr == nil {
+				contents = recoveredFile
+				// Note: Update file is corrupted, attempting to preserve instance ID
+			} else {
+				return nil, fmt.Errorf("failed to deserialize update file: %w", err)
+			}
 		}
 		instanceID = contents.InstanceID
 		previousVersion = contents.LatestVersion
@@ -106,7 +114,13 @@ func (d *defaultUpdateChecker) CheckLatestVersion() error {
 		}
 	} else {
 		if err := json.Unmarshal(rawContents, &currentFile); err != nil {
-			return fmt.Errorf("failed to deserialize update file: %w", err)
+			// If the file is corrupted, attempt to recover
+			if recoveredFile, recoverErr := recoverCorruptedJSON(rawContents); recoverErr == nil {
+				currentFile = recoveredFile
+				// Note: Recovered corrupted update file, preserving instance ID
+			} else {
+				return fmt.Errorf("failed to deserialize update file: %w", err)
+			}
 		}
 
 		// Initialize components map if it doesn't exist (for backward compatibility)
@@ -151,6 +165,15 @@ func (d *defaultUpdateChecker) CheckLatestVersion() error {
 		return fmt.Errorf("failed to marshal updated data: %w", err)
 	}
 
+	// Acquire lock just before writing to minimize lock time
+	lockFile := flock.New(d.updateFilePath + ".lock")
+	if err := lockFile.Lock(); err != nil {
+		return fmt.Errorf("failed to acquire lock on update file: %w", err)
+	}
+	defer func() {
+		_ = lockFile.Unlock()
+	}()
+
 	if err := os.WriteFile(d.updateFilePath, updatedData, 0600); err != nil {
 		return fmt.Errorf("failed to write updated file: %w", err)
 	}
@@ -181,3 +204,20 @@ func notifyIfUpdateAvailable(current, latest string) {
 		fmt.Fprintf(os.Stderr, "A new version of ToolHive is available: %s\nCurrently running: %s\n", latest, current)
 	}
 }
+
+// recoverCorruptedJSON attempts to recover from common JSON corruption issues
+// while preserving the instance_id to avoid regenerating it.
+func recoverCorruptedJSON(rawContents []byte) (updateFile, error) {
+	content := string(rawContents)
+
+	// Extract the instance_id from the corrupted JSON and regenerate the file
+	instanceIDRegex := regexp.MustCompile(`"instance_id":"([^"]+)"`)
+	if matches := instanceIDRegex.FindStringSubmatch(content); len(matches) > 1 {
+		return updateFile{
+			InstanceID: matches[1],
+			Components: make(map[string]componentInfo),
+		}, nil
+	}
+
+	return updateFile{}, fmt.Errorf("unable to recover corrupted JSON")
+}

pkg/updates/checker_test.go

@@ -330,3 +330,73 @@ func TestNotifyIfUpdateAvailable(t *testing.T) {
 		notifyIfUpdateAvailable(currentVersion, latestVersion)
 	})
 }
+
+// TestCorruptedJSONRecovery tests the recovery of corrupted update files
+func TestCorruptedJSONRecovery(t *testing.T) {
+	t.Parallel()
+
+	t.Run("recover from corrupted JSON with extra braces", func(t *testing.T) {
+		t.Parallel()
+
+		// Create corrupted JSON with extra closing braces (real example from user)
+		corruptedJSON := `{"instance_id":"test-instance-recovery","latest_version":"v0.2.3","components":{"API":{"last_check":"2025-08-01T11:12:00.740318Z"},"CLI":{"last_check":"2025-07-01T10:54:28.356601Z"},"UI":{"last_check":"2025-08-05T13:52:11.49587Z"}}}}}`
+
+		// Test recovery function directly
+		recovered, err := recoverCorruptedJSON([]byte(corruptedJSON))
+
+		// Verify recovery succeeded
+		require.NoError(t, err)
+		assert.Equal(t, "test-instance-recovery", recovered.InstanceID)
+		assert.NotNil(t, recovered.Components)
+		assert.Empty(t, recovered.LatestVersion) // Should be empty in fresh recovery
+	})
+
+	t.Run("recover from corrupted JSON in NewUpdateChecker", func(t *testing.T) {
+		t.Parallel()
+
+		// Setup corrupted file
+		tempDir, err := os.MkdirTemp("", "toolhive-corruption-test-*")
+		require.NoError(t, err)
+		defer os.RemoveAll(tempDir)
+
+		corruptedFilePath := filepath.Join(tempDir, "updates.json")
+		corruptedJSON := `{"instance_id":"test-instance-recovery","latest_version":"v0.2.3","components":{"CLI":{"last_check":"2025-08-20T09:47:11.528773Z"}}}}}`
+
+		err = os.WriteFile(corruptedFilePath, []byte(corruptedJSON), 0600)
+		require.NoError(t, err)
+
+		// Create mock client
+		mockClient := setupMockVersionClient(t)
+		mockClient.On("GetComponent").Return("CLI")
+		mockClient.On("GetLatestVersion", "test-instance-recovery", testCurrentVersion).Return(testLatestVersion, nil)
+
+		// Create update checker - this should recover from corruption during initialization
+		checker := &defaultUpdateChecker{
+			currentVersion:      testCurrentVersion,
+			updateFilePath:      corruptedFilePath,
+			versionClient:       mockClient,
+			previousAPIResponse: "",
+			component:           "CLI",
+		}
+
+		// This should work without error despite corrupted file
+		err = checker.CheckLatestVersion()
+
+		// Should not fail due to JSON corruption
+		assert.NoError(t, err)
+	})
+
+	t.Run("recovery fails when instance_id cannot be extracted", func(t *testing.T) {
+		t.Parallel()
+
+		// Create completely invalid JSON without instance_id
+		invalidJSON := `{"invalid":"json","no_instance_id":true}}`
+
+		// Test recovery function directly
+		_, err := recoverCorruptedJSON([]byte(invalidJSON))
+
+		// Should fail to recover
+		require.Error(t, err)
+		assert.Contains(t, err.Error(), "unable to recover corrupted JSON")
+	})
+}