List and sync runtimes

Author: BuriedStPatrick

bun.lockb

@@ -1,21 +1,42 @@
 import yargs, { ArgumentsCamelCase, Argv, CommandBuilder, CommandModule } from 'yargs'
-import { getInstalledSdks } from '../util/dotnet'
+import { getInstalledRuntimeVersions, getInstalledSdkVersions } from '../util/dotnet'
 import { getListPreference, outputList } from '../util/lists'
+import chalk from 'chalk'
 
 export const listCommand: CommandModule = {
   command: 'list',
   describe: 'List .NET software',
   aliases: ['ls', 'get'],
   builder: (command: CommandBuilder) => command
     .command(getSdkCommand)
+    .command(getRuntimeCommand),
+  handler: async (argv: Argv) => {
+    console.log(`${chalk.bold.bgBlue.white('Installed sdks')}`)
+    const installedSdks = await getInstalledSdkVersions()
+    outputList(installedSdks, getListPreference(argv))
+
+    console.log(`${chalk.bold.bgBlue.white('Installed runtimes')}`)
+    const installedRuntimes = await getInstalledRuntimeVersions()
+    outputList(installedRuntimes, getListPreference(argv))
+  }
 }
 
 const getSdkCommand: CommandModule = {
   command: 'sdk',
   describe: 'Get installed SDKs',
   handler: async (argv: Argv) => {
-    const installedSdks = await getInstalledSdks()
+    const installedSdks = await getInstalledSdkVersions()
 
     outputList(installedSdks, getListPreference(argv))
   }
+}
+
+const getRuntimeCommand: CommandModule = {
+  command: 'runtime',
+  describe: 'Get installed runtimes',
+  handler: async (argv: Argv) => {
+    const installedRuntimes = await getInstalledRuntimeVersions()
+
+    outputList(installedRuntimes, getListPreference(argv))
+  }
 }

commands/list.ts

@@ -1,35 +1,51 @@
 import yargs, { ArgumentsCamelCase, Argv, CommandBuilder, CommandModule } from 'yargs'
-import { fetchInstallScript, getDotnetRootPath, getInstalledSdks, hasInstallScript, syncSdk, updateSdk } from '../util/dotnet'
+import { getChannelFromVersion, getInstalledRuntimeVersions, getInstalledSdkVersions, syncRuntimeChannel, syncSdkChannel } from '../util/dotnet'
 
 export const syncCommand: CommandModule = {
-  command: 'sync',
+  command: 'sync [target]',
   describe: 'Synchronize .NET software',
   aliases: ['s'],
   builder: (command: CommandBuilder) => command
-    .command(syncSdkCommand)
-}
-
-const syncSdkCommand: CommandModule = {
-  command: 'sdk',
-  describe: 'Synchronize .NET SDKs',
-  builder: (command: CommandBuilder) => command
+    .positional('target', {
+      type: 'string',
+      describe: 'The target to sync.',
+      default: 'all',
+      choices: [
+        'all',
+        'sdk',
+        'runtime'
+      ]
+    })
     .option('channel', {
       type: 'string',
-      default: 'LTS',
-      describe: 'Channel to sync'
+      describe: 'Channel to sync.'
     }),
   handler: async (argv: Argv) => {
-    if (!(await hasInstallScript())) {
-      await fetchInstallScript()
-    }
+    // TODO: this is very stupid, but kind of amusing
+    const targets = argv.target === 'all'
+      ? ['sdk', 'runtime']
+      : [argv.target]
+
+    for (const target of targets) {
+      if (target === 'sdk') {
+        const channels: string[] = argv.channel
+          ? Array.isArray(argv.channel) ? argv.channel : [argv.channel]
+          : (await getInstalledSdkVersions()).map(version => getChannelFromVersion(version))
+
+        for (const channel of channels) {
+          await syncSdkChannel(channel)
+        }
+      }
 
-    const sdkMajorVersions = (await getInstalledSdks())
-      // distinct by major version
-      .filter((value, index, self) =>
-        index === self.findIndex(x => x.major === value.major))
+      if (target === 'runtime') {
+        const channels = argv.channel
+          ? Array.isArray(argv.channel) ? argv.channel : [argv.channel]
+          : (await getInstalledRuntimeVersions()).map(version => getChannelFromVersion(version))
 
-    for (const sdk of sdkMajorVersions) {
-      await syncSdk(sdk)
+        for (const channel of channels) {
+          await syncRuntimeChannel(channel)
+        }
+      }
     }
   }
 }

commands/sync.ts

@@ -5,12 +5,14 @@
   "version": "0.0.1",
   "devDependencies": {
     "@types/bun": "latest",
+    "@types/node": "^20.11.17",
     "@types/yargs": "^17.0.32"
   },
   "peerDependencies": {
     "typescript": "^5.0.0"
   },
   "dependencies": {
+    "chalk": "^5.3.0",
     "yargs": "^17.7.2"
   }
 }

package.json

@@ -30,48 +30,94 @@ export const getDotnetRootPath = () => {
   return path.join(Bun.env.HOME, '.dotnet')
 }
 
-export type DotnetSdk = {
+export type DotnetSdkVersion = {
   major: number
   minor: number
   patch: number
 }
 
-export type DotnetRuntime = {
+export type DotnetRuntimeVersion = {
   major: number
   minor: number
   patch: number
+  type: 'net' | 'aspnetcore' | 'netcoreapp'
 }
 
-export const getInstalledSdks = async (): Promise<DotnetSdk[]> => {
+export const getInstalledSdkVersions = async (): Promise<DotnetSdkVersion[]> => {
   const sdkPath = path.join(getDotnetRootPath(), 'sdk')
 
   const dirs = await getDirectories(sdkPath)
 
   return dirs.map(dir => {
-    const split = dir
+    const split = dir.name
       .split('.')
       .map(n => parseInt(n))
 
     return {
       major: split[0],
       minor: split[1],
-      patch: split[2]
-    } as DotnetSdk
+      patch: split[2],
+      path: dir.path
+    } as DotnetSdkVersion
   })
 }
 
-const getDirectories = async (source: string) =>
+export const getInstalledRuntimeVersions = async (): Promise<DotnetSdkVersion[]> => {
+  const netcoreRuntimePath = path.join(getDotnetRootPath(), 'shared', 'Microsoft.NETCore.App')
+  const aspnetCoreAllPath = path.join(getDotnetRootPath(), 'shared', 'Microsoft.AspNetCore.All') // old ASPNET Core 2.1 stuff
+  const aspnetCoreAppPath = path.join(getDotnetRootPath(), 'shared', 'Microsoft.AspNetCore.App')
+
+  const dirs = (await getDirectories(netcoreRuntimePath))
+    .concat((await getDirectories(aspnetCoreAllPath)))
+    .concat((await getDirectories(aspnetCoreAppPath)))
+
+  return dirs.map(dir => {
+    const versionSplit = dir.name
+      .split('.')
+      .map(n => parseInt(n))
+
+    return {
+      major: versionSplit[0],
+      minor: versionSplit[1],
+      patch: versionSplit[2],
+      type: dir.path.startsWith(netcoreRuntimePath) ? 'net'
+        : dir.path.startsWith(aspnetCoreAppPath) ? 'aspnetcore'
+        : dir.path.startsWith(aspnetCoreAllPath) ? 'netcoreapp' : null,
+      path: dir.path
+    } as DotnetRuntimeVersion
+  })
+}
+
+const getDirectories = async (source: string): Promise<Directory[]> =>
   (await readdir(source, { withFileTypes: true }))
     .filter(dirent => dirent.isDirectory())
-    .map(dirent => dirent.name)
+    .map(dirent => ({
+      name: dirent.name,
+      path: path.resolve(source, dirent.name)
+    }) as Directory)
+
+type Directory = {
+  name: string
+  path: string
+}
 
+export const syncSdkVersion = async (sdk: DotnetSdkVersion) => {
+  await syncSdkChannel(`${sdk.major}.${sdk.minor}`)
+}
+
+export const getChannelFromVersion = (version: DotnetSdkVersion | DotnetRuntimeVersion) =>
+  `${version.major}.${version.minor}`
+
+export const syncSdkChannel = async (channel: string) => {
+  if (!(await hasInstallScript())) {
+    await fetchInstallScript()
+  }
 
-export const syncSdk = async (sdk: DotnetSdk) => {
   const proc = Bun.spawn([
     'bash',
     getInstallScriptPath(),
     '--channel',
-    `${sdk.major}.${sdk.minor}`
+    channel
   ], {
     stdout: 'inherit',
     stderr: 'inherit',
@@ -88,12 +134,19 @@ export const syncSdk = async (sdk: DotnetSdk) => {
   }
 }
 
-export const syncRuntime = async (runtime: DotnetRuntime) => {
+export const syncRuntime = async (runtime: DotnetRuntimeVersion) =>
+  await syncRuntimeChannel(`${runtime.major}/${runtime.minor}`)
+
+export const syncRuntimeChannel = async (channel: string) => {
+  if (!(await hasInstallScript())) {
+    await fetchInstallScript()
+  }
+
   const proc = Bun.spawn([
     'bash',
     getInstallScriptPath(),
     '--channel',
-    `${runtime.major}.${runtime.minor}`,
+    channel,
     '--runtime'
   ], {
     stdout: 'inherit',