Add Swiftly toolchain management

roulpriya · roulpriya · commit 3d12c9f25087 · 2025-07-16T18:34:02.000+05:30
diff --git a/package-lock.json b/package-lock.json
diff --git a/package.json b/package.json
@@ -1829,6 +1829,7 @@
     "lcov-parse": "^1.0.0",
     "plist": "^3.1.0",
     "vscode-languageclient": "^9.0.1",
-    "xml2js": "^0.6.2"
+    "xml2js": "^0.6.2",
+    "zod": "^4.0.5"
   }
 }
diff --git a/src/toolchain/swiftly.ts b/src/toolchain/swiftly.ts
@@ -0,0 +1,157 @@
+import * as path from "node:path";
+import { SwiftlyConfig } from "./ToolchainVersion";
+import * as fs from "node:fs/promises";
+import { execFile, ExecFileError } from "../utilities/utilities";
+import * as vscode from "vscode";
+import { Version } from "../utilities/version";
+import { z } from "zod";
+
+const ListAvailableResult = z.object({
+    toolchains: z.array(
+        z.object({
+            inUse: z.boolean(),
+            installed: z.boolean(),
+            isDefault: z.boolean(),
+            name: z.string(),
+            version: z.discriminatedUnion("type", [
+                z.object({
+                    major: z.number(),
+                    minor: z.number(),
+                    patch: z.number().optional(),
+                    type: z.literal("stable"),
+                }),
+                z.object({
+                    major: z.number(),
+                    minor: z.number(),
+                    branch: z.string(),
+                    date: z.string(),
+
+                    type: z.literal("snapshot"),
+                }),
+            ]),
+        })
+    ),
+});
+
+export class Swiftly {
+    /**
+     * Finds the version of Swiftly installed on the system.
+     *
+     * @returns the version of Swiftly as a `Version` object, or `undefined`
+     * if Swiftly is not installed or not supported.
+     */
+    public async getSwiftlyVersion(): Promise<Version | undefined> {
+        if (!this.isSupported()) {
+            return undefined;
+        }
+        const { stdout } = await execFile("swiftly", ["--version"]);
+        return Version.fromString(stdout.trim());
+    }
+
+    /**
+     * Finds the list of toolchains managed by Swiftly.
+     *
+     * @returns an array of toolchain paths
+     */
+    public async getSwiftlyToolchainInstalls(): Promise<string[]> {
+        if (!this.isSupported()) {
+            return [];
+        }
+        const version = await swiftly.getSwiftlyVersion();
+        if (version?.isLessThan(new Version(1, 1, 0))) {
+            return await this.getToolchainInstallLegacy();
+        }
+
+        return await this.getListAvailableToolchains();
+    }
+
+    private async getListAvailableToolchains(): Promise<string[]> {
+        try {
+            const { stdout } = await execFile("swiftly", ["list-available", "--format=json"]);
+            const response = ListAvailableResult.parse(JSON.parse(stdout));
+            return response.toolchains.map(t => t.name);
+        } catch (error) {
+            throw new Error("Failed to retrieve Swiftly installations from disk.");
+        }
+    }
+
+    private async getToolchainInstallLegacy() {
+        try {
+            const swiftlyHomeDir: string | undefined = process.env["SWIFTLY_HOME_DIR"];
+            if (!swiftlyHomeDir) {
+                return [];
+            }
+            const swiftlyConfig = await swiftly.getSwiftlyConfig();
+            if (!swiftlyConfig || !("installedToolchains" in swiftlyConfig)) {
+                return [];
+            }
+            const installedToolchains = swiftlyConfig.installedToolchains;
+            if (!Array.isArray(installedToolchains)) {
+                return [];
+            }
+            return installedToolchains
+                .filter((toolchain): toolchain is string => typeof toolchain === "string")
+                .map(toolchain => path.join(swiftlyHomeDir, "toolchains", toolchain));
+        } catch (error) {
+            throw new Error("Failed to retrieve Swiftly installations from disk.");
+        }
+    }
+
+    private isSupported() {
+        return process.platform === "linux" || process.platform === "darwin";
+    }
+
+    public async swiftlyInUseLocation(swiftlyPath: string, cwd?: vscode.Uri) {
+        const { stdout: inUse } = await execFile(swiftlyPath, ["use", "--print-location"], {
+            cwd: cwd?.fsPath,
+        });
+        return inUse.trimEnd();
+    }
+
+    /**
+     * Determine if Swiftly is being used to manage the active toolchain and if so, return
+     * the path to the active toolchain.
+     * @returns The location of the active toolchain if swiftly is being used to manage it.
+     */
+    public async swiftlyToolchain(cwd?: vscode.Uri): Promise<string | undefined> {
+        const swiftlyHomeDir: string | undefined = process.env["SWIFTLY_HOME_DIR"];
+        if (swiftlyHomeDir) {
+            const { stdout: swiftLocation } = await execFile("which", ["swift"]);
+            if (swiftLocation.startsWith(swiftlyHomeDir)) {
+                // Print the location of the toolchain that swiftly is using. If there
+                // is no cwd specified then it returns the global "inUse" toolchain otherwise
+                // it respects the .swift-version file in the cwd and resolves using that.
+                try {
+                    const inUse = await swiftly.swiftlyInUseLocation("swiftly", cwd);
+                    if (inUse.length > 0) {
+                        return path.join(inUse, "usr");
+                    }
+                } catch (err: unknown) {
+                    const error = err as ExecFileError;
+                    // Its possible the toolchain in .swift-version is misconfigured or doesn't exist.
+                    void vscode.window.showErrorMessage(`${error.stderr}`);
+                }
+            }
+        }
+        return undefined;
+    }
+
+    /**
+     * Reads the Swiftly configuration file, if it exists.
+     *
+     * @returns A parsed Swiftly configuration.
+     */
+    private async getSwiftlyConfig(): Promise<SwiftlyConfig | undefined> {
+        const swiftlyHomeDir: string | undefined = process.env["SWIFTLY_HOME_DIR"];
+        if (!swiftlyHomeDir) {
+            return;
+        }
+        const swiftlyConfigRaw = await fs.readFile(
+            path.join(swiftlyHomeDir, "config.json"),
+            "utf-8"
+        );
+        return JSON.parse(swiftlyConfigRaw);
+    }
+}
+
+export const swiftly = new Swiftly();
diff --git a/src/toolchain/toolchain.ts b/src/toolchain/toolchain.ts
@@ -19,13 +19,13 @@ import * as plist from "plist";
 import * as vscode from "vscode";
 import configuration from "../configuration";
 import { SwiftOutputChannel } from "../ui/SwiftOutputChannel";
-import { execFile, ExecFileError, execSwift } from "../utilities/utilities";
+import { execFile, execSwift } from "../utilities/utilities";
 import { expandFilePathTilde, fileExists, pathExists } from "../utilities/filesystem";
 import { Version } from "../utilities/version";
 import { BuildFlags } from "./BuildFlags";
 import { Sanitizer } from "./Sanitizer";
-import { SwiftlyConfig } from "./ToolchainVersion";
 import { lineBreakRegex } from "../utilities/tasks";
+import { swiftly } from "./swiftly";
 
 /**
  * Contents of **Info.plist** on Windows.
@@ -251,54 +251,6 @@ export class SwiftToolchain {
         return result;
     }
 
-    /**
-     * Finds the list of toolchains managed by Swiftly.
-     *
-     * @returns an array of toolchain paths
-     */
-    public static async getSwiftlyToolchainInstalls(): Promise<string[]> {
-        // Swiftly is available on Linux and macOS
-        if (process.platform !== "linux" && process.platform !== "darwin") {
-            return [];
-        }
-        try {
-            const swiftlyHomeDir: string | undefined = process.env["SWIFTLY_HOME_DIR"];
-            if (!swiftlyHomeDir) {
-                return [];
-            }
-            const swiftlyConfig = await SwiftToolchain.getSwiftlyConfig();
-            if (!swiftlyConfig || !("installedToolchains" in swiftlyConfig)) {
-                return [];
-            }
-            const installedToolchains = swiftlyConfig.installedToolchains;
-            if (!Array.isArray(installedToolchains)) {
-                return [];
-            }
-            return installedToolchains
-                .filter((toolchain): toolchain is string => typeof toolchain === "string")
-                .map(toolchain => path.join(swiftlyHomeDir, "toolchains", toolchain));
-        } catch (error) {
-            throw new Error("Failed to retrieve Swiftly installations from disk.");
-        }
-    }
-
-    /**
-     * Reads the Swiftly configuration file, if it exists.
-     *
-     * @returns A parsed Swiftly configuration.
-     */
-    private static async getSwiftlyConfig(): Promise<SwiftlyConfig | undefined> {
-        const swiftlyHomeDir: string | undefined = process.env["SWIFTLY_HOME_DIR"];
-        if (!swiftlyHomeDir) {
-            return;
-        }
-        const swiftlyConfigRaw = await fs.readFile(
-            path.join(swiftlyHomeDir, "config.json"),
-            "utf-8"
-        );
-        return JSON.parse(swiftlyConfigRaw);
-    }
-
     /**
      * Checks common directories for available swift toolchain installations.
      *
@@ -615,7 +567,7 @@ export class SwiftToolchain {
             let realSwift = await fs.realpath(swift);
             if (path.basename(realSwift) === "swiftly") {
                 try {
-                    const inUse = await this.swiftlyInUseLocation(realSwift, cwd);
+                    const inUse = await swiftly.swiftlyInUseLocation(realSwift, cwd);
                     if (inUse) {
                         realSwift = path.join(inUse, "usr", "bin", "swift");
                     }
@@ -668,7 +620,7 @@ export class SwiftToolchain {
                         const swiftlyPath = path.join(configPath, "swiftly");
                         if (await fileExists(swiftlyPath)) {
                             try {
-                                const inUse = await this.swiftlyInUseLocation(swiftlyPath, cwd);
+                                const inUse = await swiftly.swiftlyInUseLocation(swiftlyPath, cwd);
                                 if (inUse) {
                                     return path.join(inUse, "usr");
                                 }
@@ -679,7 +631,7 @@ export class SwiftToolchain {
                         return path.dirname(configuration.path);
                     }
 
-                    const swiftlyToolchainLocation = await this.swiftlyToolchain(cwd);
+                    const swiftlyToolchainLocation = await swiftly.swiftlyToolchain(cwd);
                     if (swiftlyToolchainLocation) {
                         return swiftlyToolchainLocation;
                     }
@@ -699,41 +651,6 @@ export class SwiftToolchain {
         }
     }
 
-    private static async swiftlyInUseLocation(swiftlyPath: string, cwd?: vscode.Uri) {
-        const { stdout: inUse } = await execFile(swiftlyPath, ["use", "--print-location"], {
-            cwd: cwd?.fsPath,
-        });
-        return inUse.trimEnd();
-    }
-
-    /**
-     * Determine if Swiftly is being used to manage the active toolchain and if so, return
-     * the path to the active toolchain.
-     * @returns The location of the active toolchain if swiftly is being used to manage it.
-     */
-    private static async swiftlyToolchain(cwd?: vscode.Uri): Promise<string | undefined> {
-        const swiftlyHomeDir: string | undefined = process.env["SWIFTLY_HOME_DIR"];
-        if (swiftlyHomeDir) {
-            const { stdout: swiftLocation } = await execFile("which", ["swift"]);
-            if (swiftLocation.indexOf(swiftlyHomeDir) === 0) {
-                // Print the location of the toolchain that swiftly is using. If there
-                // is no cwd specified then it returns the global "inUse" toolchain otherwise
-                // it respects the .swift-version file in the cwd and resolves using that.
-                try {
-                    const inUse = await this.swiftlyInUseLocation("swiftly", cwd);
-                    if (inUse.length > 0) {
-                        return path.join(inUse, "usr");
-                    }
-                } catch (err: unknown) {
-                    const error = err as ExecFileError;
-                    // Its possible the toolchain in .swift-version is misconfigured or doesn't exist.
-                    void vscode.window.showErrorMessage(`${error.stderr}`);
-                }
-            }
-        }
-        return undefined;
-    }
-
     /**
      * @param targetInfo swift target info
      * @returns path to Swift runtime
diff --git a/src/ui/ToolchainSelection.ts b/src/ui/ToolchainSelection.ts
@@ -18,6 +18,7 @@ import { showReloadExtensionNotification } from "./ReloadExtension";
 import { SwiftToolchain } from "../toolchain/toolchain";
 import configuration from "../configuration";
 import { Commands } from "../commands";
+import { swiftly } from "../toolchain/swiftly";
 
 /**
  * Open the installation page on Swift.org
@@ -192,7 +193,7 @@ async function getQuickPickItems(
             return result;
         });
     // Find any Swift toolchains installed via Swiftly
-    const swiftlyToolchains = (await SwiftToolchain.getSwiftlyToolchainInstalls())
+    const swiftlyToolchains = (await swiftly.getSwiftlyToolchainInstalls())
         .reverse()
         .map<SwiftToolchainItem>(toolchainPath => ({
             type: "toolchain",
diff --git a/test/unit-tests/toolchain/swiftly.test.ts b/test/unit-tests/toolchain/swiftly.test.ts

Original file line number	Diff line number	Diff line change
`@@ -1829,6 +1829,7 @@`
`1829`	`1829`	`"lcov-parse": "^1.0.0",`
`1830`	`1830`	`"plist": "^3.1.0",`
`1831`	`1831`	`"vscode-languageclient": "^9.0.1",`
`1832`		`- "xml2js": "^0.6.2"`
	`1832`	`+ "xml2js": "^0.6.2",`
	`1833`	`+ "zod": "^4.0.5"`
`1833`	`1834`	`}`
`1834`	`1835`	`}`