v18.1.2

Move macos binary signing to oclif pretarball lifecycle

.eslintignore

@@ -0,0 +1,2 @@
+/completion/*
+/bin/*

.eslintrc.js

@@ -0,0 +1,21 @@
+module.exports = {
+	extends: ['./node_modules/@balena/lint/config/.eslintrc.js'],
+	parserOptions: {
+		project: 'tsconfig.dev.json',
+	},
+	root: true,
+	rules: {
+		ignoreDefinitionFiles: 0,
+		// to avoid the `warning  Forbidden non-null assertion  @typescript-eslint/no-non-null-assertion`
+		'@typescript-eslint/no-non-null-assertion': 'off',
+		'@typescript-eslint/no-shadow': 'off',
+		'@typescript-eslint/no-var-requires': 'off',
+		'no-restricted-imports': [
+			'error',
+			{
+				paths: ['resin-cli-visuals', 'chalk', 'common-tags', 'resin-cli-form'],
+			},
+		],
+		'@typescript-eslint/no-unused-vars': ['error', { argsIgnorePattern: '^_' }],
+	},
+};

.gitattributes

@@ -4,6 +4,10 @@
 *.* -eol
 
 *.sh text eol=lf
+.dockerignore eol=lf
+Dockerfile eol=lf
+Dockerfile.* eol=lf
+* text=auto eol=lf
 
 # lf for the docs as it's auto-generated and will otherwise trigger an uncommited error on windows
 docs/balena-cli.md text eol=lf

.github/actions/publish/action.yml

@@ -0,0 +1,143 @@
+---
+name: package and draft GitHub release
+# https://github.com/product-os/flowzone/tree/master/.github/actions
+inputs:
+  json:
+    description: 'JSON stringified object containing all the inputs from the calling workflow'
+    required: true
+  secrets:
+    description: 'JSON stringified object containing all the secrets from the calling workflow'
+    required: true
+  variables:
+    description: 'JSON stringified object containing all the variables from the calling workflow'
+    required: true
+
+  # --- custom environment
+  XCODE_APP_LOADER_EMAIL:
+    type: string
+    default: 'accounts+apple@balena.io'
+  NODE_VERSION:
+    type: string
+    default: '20.x'
+  VERBOSE:
+    type: string
+    default: 'true'
+
+runs:
+  # https://docs.github.com/en/actions/creating-actions/creating-a-composite-action
+  using: 'composite'
+  steps:
+    - name: Download custom source artifact
+      uses: actions/download-artifact@f44cd7b40bfd40b6aa1cc1b9b5b7bf03d3c67110 # v4.1.0
+      with:
+        name: custom-${{ github.event.pull_request.head.sha || github.event.head_commit.id }}-${{ runner.os }}-${{ runner.arch }}
+        path: ${{ runner.temp }}
+
+    - name: Extract custom source artifact
+      shell: pwsh
+      working-directory: .
+      run: tar -xf ${{ runner.temp }}/custom.tgz
+
+    - name: Setup Node.js
+      uses: actions/setup-node@v3
+      with:
+        node-version: ${{ inputs.NODE_VERSION }}
+        cache: npm
+
+    - name: Set up Python 3.11
+      if: runner.os == 'macOS'
+      uses: actions/setup-python@d27e3f3d7c64b4bbf8e4abfb9b63b83e846e0435 # v4
+      with:
+        python-version: "3.11"
+
+    - name: Install additional tools
+      if: runner.os == 'Windows'
+      shell: bash
+      run: |
+        choco install yq
+
+    - name: Install additional tools
+      if: runner.os == 'macOS'
+      shell: bash
+      run: |
+        brew install coreutils
+
+    # https://www.electron.build/code-signing.html
+    # https://github.com/Apple-Actions/import-codesign-certs
+    - name: Import Apple code signing certificate
+      if: runner.os == 'macOS'
+      uses: apple-actions/import-codesign-certs@v1
+      with:
+        p12-file-base64: ${{ fromJSON(inputs.secrets).APPLE_SIGNING }}
+        p12-password: ${{ fromJSON(inputs.secrets).APPLE_SIGNING_PASSWORD }}
+
+    - name: Import Windows code signing certificate
+      if: runner.os == 'Windows'
+      shell: powershell
+      run: |
+        Set-Content -Path ${{ runner.temp }}/certificate.base64 -Value $env:SM_CLIENT_CERT_FILE_B64
+        certutil -decode ${{ runner.temp }}/certificate.base64 ${{ runner.temp }}/Certificate_pkcs12.p12
+        Remove-Item -path ${{ runner.temp }} -include certificate.base64
+      env:
+        SM_CLIENT_CERT_FILE_B64: ${{ fromJSON(inputs.secrets).SM_CLIENT_CERT_FILE_B64 }}
+
+    # https://github.com/product-os/scripts/tree/master/shared
+    # https://github.com/product-os/balena-concourse/blob/master/pipelines/github-events/template.yml
+    - name: Package release
+      shell: bash
+      run: |
+        set -ea
+
+        [[ '${{ inputs.VERBOSE }}' =~ on|On|Yes|yes|true|True ]] && set -x
+
+        runner_os="$(echo "${RUNNER_OS}" | tr '[:upper:]' '[:lower:]')"
+        runner_arch="$(echo "${RUNNER_ARCH}" | tr '[:upper:]' '[:lower:]')"
+
+        if [[ $runner_os =~ darwin|macos|osx ]]; then
+            CSC_KEY_PASSWORD=${{ fromJSON(inputs.secrets).APPLE_SIGNING_PASSWORD }}
+            CSC_KEYCHAIN=signing_temp
+            CSC_LINK=${{ fromJSON(inputs.secrets).APPLE_SIGNING }}
+
+        elif [[ $runner_os =~ windows|win ]]; then
+            SM_HOST=${{ fromJSON(inputs.secrets).SM_HOST }}
+            SM_API_KEY=${{ fromJSON(inputs.secrets).SM_API_KEY }}
+            SM_CLIENT_CERT_FILE='${{ runner.temp }}\Certificate_pkcs12.p12'
+            SM_CLIENT_CERT_PASSWORD=${{ fromJSON(inputs.secrets).SM_CLIENT_CERT_PASSWORD }}
+            SM_CODE_SIGNING_CERT_SHA1_HASH=${{ fromJSON(inputs.secrets).SM_CODE_SIGNING_CERT_SHA1_HASH }}
+
+            curl --silent --retry 3 --fail https://one.digicert.com/signingmanager/api-ui/v1/releases/smtools-windows-x64.msi/download \
+              -H "x-api-key:$SM_API_KEY" \
+              -o smtools-windows-x64.msi
+            msiexec -i smtools-windows-x64.msi -qn
+            PATH="/c/Program Files/DigiCert/DigiCert One Signing Manager Tools:${PATH}"
+            smksp_registrar.exe list
+            smctl.exe keypair ls
+            /c/Windows/System32/certutil.exe -csp "DigiCert Signing Manager KSP" -key -user
+            smksp_cert_sync.exe
+
+            # (signtool.exe) https://github.com/actions/runner-images/blob/main/images/win/Windows2019-Readme.md#installed-windows-sdks
+            PATH="/c/Program Files (x86)/Windows Kits/10/bin/${runner_arch}:${PATH}"
+        fi
+
+        npm run package
+
+        find dist -type f -maxdepth 1
+
+      env:
+        # https://github.blog/2020-08-03-github-actions-improvements-for-fork-and-pull-request-workflows/#improvements-for-public-repository-forks
+        # https://docs.github.com/en/actions/managing-workflow-runs/approving-workflow-runs-from-public-forks#about-workflow-runs-from-public-forks
+        CSC_FOR_PULL_REQUEST: true
+        # https://docs.digicert.com/es/software-trust-manager/ci-cd-integrations/plugins/github-custom-action-for-keypair-signing.html
+        TIMESTAMP_SERVER: http://timestamp.digicert.com
+        # Apple notarization (automation/build-bin.ts)
+        XCODE_APP_LOADER_EMAIL: ${{ inputs.XCODE_APP_LOADER_EMAIL }}
+        XCODE_APP_LOADER_PASSWORD: ${{ fromJSON(inputs.secrets).XCODE_APP_LOADER_PASSWORD }}
+        XCODE_APP_LOADER_TEAM_ID: ${{ inputs.XCODE_APP_LOADER_TEAM_ID }}
+
+    - name: Upload artifacts
+      uses: actions/upload-artifact@c7d193f32edcb7bfad88892161225aeda64e9392 # v4
+      with:
+        name: gh-release-${{ github.event.pull_request.head.sha || github.event.head_commit.id }}-${{ strategy.job-index }}
+        path: dist
+        retention-days: 1
+        if-no-files-found: error

.github/actions/test/action.yml

@@ -0,0 +1,65 @@
+---
+name: test release
+# https://github.com/product-os/flowzone/tree/master/.github/actions
+inputs:
+  json:
+    description: "JSON stringified object containing all the inputs from the calling workflow"
+    required: true
+  secrets:
+    description: "JSON stringified object containing all the secrets from the calling workflow"
+    required: true
+  variables:
+    description: "JSON stringified object containing all the variables from the calling workflow"
+    required: true
+
+  # --- custom environment
+  NODE_VERSION:
+    type: string
+    default: '20.x'
+  VERBOSE:
+    type: string
+    default: "true"
+
+runs:
+  # https://docs.github.com/en/actions/creating-actions/creating-a-composite-action
+  using: "composite"
+  steps:
+    # https://github.com/actions/setup-node#caching-global-packages-data
+    - name: Setup Node.js
+      uses: actions/setup-node@v3
+      with:
+        node-version: ${{ inputs.NODE_VERSION }}
+        cache: npm
+
+    - name: Set up Python 3.11
+      if: runner.os == 'macOS'
+      uses: actions/setup-python@d27e3f3d7c64b4bbf8e4abfb9b63b83e846e0435 # v4
+      with:
+        python-version: "3.11"
+
+    - name: Test release
+      shell: bash
+      run: |
+        set -ea
+
+        [[ '${{ inputs.VERBOSE }}' =~ on|On|Yes|yes|true|True ]] && set -x
+
+        if [[ -e package-lock.json ]] || [[ -e npm-shrinkwrap.json ]]; then
+            npm ci
+        else
+            npm i
+        fi
+
+        npm run build
+        npm run test:core
+
+    - name: Compress custom source
+      shell: pwsh
+      run: tar --exclude-vcs -acf ${{ runner.temp }}/custom.tgz .
+
+    - name: Upload custom artifact
+      uses: actions/upload-artifact@c7d193f32edcb7bfad88892161225aeda64e9392 # v4
+      with:
+        name: custom-${{ github.event.pull_request.head.sha || github.event.head_commit.id }}-${{ runner.os }}-${{ runner.arch }}
+        path: ${{ runner.temp }}/custom.tgz
+        retention-days: 1

.github/workflows/flowzone.yml

@@ -0,0 +1,26 @@
+name: Flowzone
+on:
+  pull_request:
+    types: [opened, synchronize, closed]
+    branches: [main, master]
+  pull_request_target:
+    types: [opened, synchronize, closed]
+    branches: [main, master]
+jobs:
+  flowzone:
+    name: Flowzone
+    uses: product-os/flowzone/.github/workflows/flowzone.yml@master
+    # prevent duplicate workflow executions for pull_request and pull_request_target
+    if: |
+      (
+        github.event.pull_request.head.repo.full_name == github.repository &&
+        github.event_name == 'pull_request'
+      ) || (
+        github.event.pull_request.head.repo.full_name != github.repository &&
+        github.event_name == 'pull_request_target'
+      )
+    secrets: inherit
+    with:
+      custom_runs_on: '[["self-hosted","Linux","distro:focal","X64"],["self-hosted","Linux","distro:focal","ARM64"],["macos-12"],["windows-2019"],["macos-latest-xlarge"]]'
+      github_prerelease: false
+      restrict_custom_actions: false

.resinci.yml

@@ -1,20 +0,0 @@
----
-npm:
-  platforms:
-    - name: linux
-      os: ubuntu
-      architecture: x86_64
-      node_versions:
-        - "12"
-        - "14"
-    ##
-    ## Temporarily skip Alpine tests until the following issues are resolved:
-    ##   * https://github.com/concourse/concourse/issues/7905
-    ##   * https://github.com/product-os/balena-concourse/issues/631
-    ##
-    # - name: linux
-    #   os: alpine
-    #   architecture: x86_64
-    #   node_versions:
-    #     - "12"
-    #     - "14"

CONTRIBUTING.md

@@ -123,6 +123,20 @@ The README file is manually edited, but subsections are automatically extracted
 `docs/balena-cli.md` by the `getCapitanoDoc()` function in
 [`automation/capitanodoc/capitanodoc.ts`](https://github.com/balena-io/balena-cli/blob/master/automation/capitanodoc/capitanodoc.ts).
 
+**IMPORTANT**
+
+The file [`capitanodoc.ts`](https://github.com/balena-io/balena-cli/blob/master/automation/capitanodoc/capitanodoc.ts) lists 
+commands to generate documentation from. At the moment, it's manually updated and maintained alphabetically. 
+
+To add a new command to be documented, 
+
+1. Find the resource which it is part of or create a new one. 
+2. List the location of the build file 
+3. Make sure to add your files in alphabetical order
+4. Resources with plural names needs to have 2 sections if they have commands like: "fleet, fleets" or "device, devices" or "tag, tags"
+
+Once added, run the command `npm run build` to generate the documentation
+
 The `INSTALL*.md` and `TROUBLESHOOTING.md` files are also manually edited.
 
 ## Patches folder

INSTALL-ADVANCED.md

@@ -78,8 +78,8 @@ If you are a Node.js developer, you may wish to install the balena CLI via [npm]
 The npm installation involves building native (platform-specific) binary modules, which require
 some development tools to be installed first, as follows.
 
-> **The balena CLI currently requires Node.js version 12 (min 12.8.0).**  
-> **Versions 13 and later are not yet fully supported.**
+> **The balena CLI currently requires Node.js version 20.**
+> **Versions 21 and later are not yet fully supported.**
 
 ### Install development tools
 
@@ -89,7 +89,7 @@ some development tools to be installed first, as follows.
 $ sudo apt-get update && sudo apt-get -y install curl python3 git make g++
 $ curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.38.0/install.sh | bash
 $ . ~/.bashrc
-$ nvm install 12
+$ nvm install 20
 ```
 
 The `curl` command line above uses
@@ -106,15 +106,15 @@ recommended.
 ```sh
 $ curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.38.0/install.sh | bash
 $ . ~/.bashrc
-$ nvm install 12
+$ nvm install 20
 ```
 
 #### **Windows** (not WSL)
 
 Install:
 
-* Node.js v12 from the [Nodejs.org releases page](https://nodejs.org/en/download/releases/).
   * If you'd like the ability to switch between Node.js versions, install
+- Node.js v20 from the [Nodejs.org releases page](https://nodejs.org/en/download/releases/).
     [nvm-windows](https://github.com/coreybutler/nvm-windows#node-version-manager-nvm-for-windows)
     instead.
 * The [MSYS2 shell](https://www.msys2.org/), which provides `git`, `make`, `g++` and more:

automation/build-bin.ts

@@ -15,21 +15,21 @@
  * limitations under the License.
  */
 
-import type { JsonVersions } from '../lib/commands/version';
+import type { JsonVersions } from '../lib/commands/version/index';
 
-import { run as oclifRun } from 'oclif';
+import { run as oclifRun } from '@oclif/core';
 import * as archiver from 'archiver';
 import * as Bluebird from 'bluebird';
-import { execFile } from 'child_process';
+import { exec, execFile } from 'child_process';
 import * as filehound from 'filehound';
 import { Stats } from 'fs';
 import * as fs from 'fs-extra';
 import * as klaw from 'klaw';
-import * as _ from 'lodash';
 import * as path from 'path';
 import * as rimraf from 'rimraf';
 import * as semver from 'semver';
 import { promisify } from 'util';
+import { notarize } from '@electron/notarize';
 
 import { stripIndent } from '../build/utils/lazy';
 import {
@@ -41,12 +41,11 @@ import {
 } from './utils';
 
 const execFileAsync = promisify(execFile);
+const execAsync = promisify(exec);
 
 export const packageJSON = loadPackageJson();
 export const version = 'v' + packageJSON.version;
 const arch = process.arch;
-const MSYS2_BASH =
-	process.env.MSYSSHELLPATH || 'C:\\msys64\\usr\\bin\\bash.exe';
 
 function dPath(...paths: string[]) {
 	return path.join(ROOT, 'dist', ...paths);
@@ -62,9 +61,13 @@ const standaloneZips: PathByPlatform = {
 	win32: dPath(`balena-cli-${version}-windows-${arch}-standalone.zip`),
 };
 
-const oclifInstallers: PathByPlatform = {
-	darwin: dPath('macos', `balena-${version}.pkg`),
-	win32: dPath('win32', `balena-${version}-${arch}.exe`),
+const getOclifInstallersOriginalNames = async (): Promise<PathByPlatform> => {
+	const { stdout } = await execAsync('git rev-parse --short HEAD');
+	const sha = stdout.trim();
+	return {
+		darwin: dPath('macos', `balena-${version}-${sha}-${arch}.pkg`),
+		win32: dPath('win32', `balena-${version}-${sha}-${arch}.exe`),
+	};
 };
 
 const renamedOclifInstallers: PathByPlatform = {
@@ -89,7 +92,7 @@ async function diffPkgOutput(pkgOut: string) {
 		'tests',
 		'test-data',
 		'pkg',
-		`expected-warnings-${process.platform}.txt`,
+		`expected-warnings-${process.platform}-${arch}.txt`,
 	);
 	const absSavedPath = path.join(ROOT, relSavedPath);
 	const ignoreStartsWith = [
@@ -157,7 +160,7 @@ ${sep}
  * messages (stdout and stderr) in order to call diffPkgOutput().
  */
 async function execPkg(...args: any[]) {
-	const { exec: pkgExec } = await import('pkg');
+	const { exec: pkgExec } = await import('@yao-pkg/pkg');
 	const outTap = new StdOutTap(true);
 	try {
 		outTap.tap();
@@ -182,9 +185,18 @@ async function execPkg(...args: any[]) {
  * to be directly executed from inside another binary executable.)
  */
 async function buildPkg() {
+	// https://github.com/vercel/pkg#targets
+	let targets = `linux-${arch}`;
+	if (process.platform === 'darwin') {
+		targets = `macos-${arch}`;
+	}
+	// TBC: not yet possible to build for Windows arm64 on x64 nodes
+	if (process.platform === 'win32') {
+		targets = `win-x64`;
+	}
 	const args = [
-		'--target',
-		'host',
+		'--targets',
+		targets,
 		'--output',
 		'build-bin/balena',
 		'package.json',
@@ -199,7 +211,6 @@ async function buildPkg() {
 	const paths: Array<[string, string[], string[]]> = [
 		// [platform, [source path], [destination path]]
 		['*', ['open', 'xdg-open'], ['xdg-open']],
-		['*', ['opn', 'xdg-open'], ['xdg-open-402']],
 		['darwin', ['denymount', 'bin', 'denymount'], ['denymount']],
 	];
 	await Promise.all(
@@ -315,7 +326,11 @@ async function zipPkg() {
 	});
 }
 
-async function signFilesForNotarization() {
+export async function signFilesForNotarization() {
+	console.log('Signing files for notarization');
+	if (process.platform !== 'darwin') {
+		return;
+	}
 	console.log('Deleting unneeded zip files...');
 	await new Promise((resolve, reject) => {
 		klaw('node_modules/')
@@ -415,6 +430,7 @@ export async function buildStandaloneZip() {
 }
 
 async function renameInstallerFiles() {
+	const oclifInstallers = await getOclifInstallersOriginalNames();
 	if (await fs.pathExists(oclifInstallers[process.platform])) {
 		await fs.rename(
 			oclifInstallers[process.platform],
@@ -425,20 +441,30 @@ async function renameInstallerFiles() {
 
 /**
  * If the CSC_LINK and CSC_KEY_PASSWORD env vars are set, digitally sign the
- * executable installer by running the balena-io/scripts/shared/sign-exe.sh
- * script (which must be in the PATH) using a MSYS2 bash shell.
+ * executable installer using Microsoft SignTool.exe (Sign Tool)
+ * https://learn.microsoft.com/en-us/dotnet/framework/tools/signtool-exe
  */
 async function signWindowsInstaller() {
-	if (process.env.CSC_LINK && process.env.CSC_KEY_PASSWORD) {
+	if (process.env.SM_CODE_SIGNING_CERT_SHA1_HASH) {
 		const exeName = renamedOclifInstallers[process.platform];
 		console.log(`Signing installer "${exeName}"`);
-		await execFileAsync(MSYS2_BASH, [
-			'sign-exe.sh',
-			'-f',
-			exeName,
+		// trust ...
+		await execFileAsync('signtool.exe', [
+			'sign',
+			'-sha1',
+			process.env.SM_CODE_SIGNING_CERT_SHA1_HASH,
+			'-tr',
+			process.env.TIMESTAMP_SERVER || 'http://timestamp.comodoca.com',
+			'-td',
+			'SHA256',
+			'-fd',
+			'SHA256',
 			'-d',
 			`balena-cli ${version}`,
+			exeName,
 		]);
+		// ... but verify
+		await execFileAsync('signtool.exe', ['verify', '-pa', '-v', exeName]);
 	} else {
 		console.log(
 			'Skipping installer signing step because CSC_* env vars are not set',
@@ -450,14 +476,20 @@ async function signWindowsInstaller() {
  * Wait for Apple Installer Notarization to continue
  */
 async function notarizeMacInstaller(): Promise<void> {
-	const appleId = 'accounts+apple@balena.io';
-	const { notarize } = await import('electron-notarize');
-	await notarize({
-		appBundleId: 'io.balena.etcher',
-		appPath: renamedOclifInstallers.darwin,
-		appleId,
-		appleIdPassword: '@keychain:CLI_PASSWORD',
-	});
+	const teamId = process.env.XCODE_APP_LOADER_TEAM_ID || '66H43P8FRG';
+	const appleId =
+		process.env.XCODE_APP_LOADER_EMAIL || 'accounts+apple@balena.io';
+	const appleIdPassword = process.env.XCODE_APP_LOADER_PASSWORD;
+
+	if (appleIdPassword && teamId) {
+		await notarize({
+			tool: 'notarytool',
+			teamId,
+			appPath: renamedOclifInstallers.darwin,
+			appleId,
+			appleIdPassword,
+		});
+	}
 }
 
 /**
@@ -471,9 +503,10 @@ export async function buildOclifInstaller() {
 	let packOpts = ['-r', ROOT];
 	if (process.platform === 'darwin') {
 		packOS = 'macos';
+		packOpts = packOpts.concat('--targets', `darwin-${arch}`);
 	} else if (process.platform === 'win32') {
 		packOS = 'win';
-		packOpts = packOpts.concat('-t', 'win32-x64');
+		packOpts = packOpts.concat('--targets', 'win32-x64');
 	}
 	if (packOS) {
 		console.log(`Building oclif installer for CLI ${version}`);
@@ -486,15 +519,12 @@ export async function buildOclifInstaller() {
 			console.log(`rimraf(${dir})`);
 			await Bluebird.fromCallback((cb) => rimraf(dir, cb));
 		}
-		if (process.platform === 'darwin') {
-			console.log('Signing files for notarization...');
-			await signFilesForNotarization();
-		}
 		console.log('=======================================================');
-		console.log(`oclif "${packCmd}" "${packOpts.join('" "')}"`);
+		console.log(`oclif ${packCmd} ${packOpts.join(' ')}`);
 		console.log(`cwd="${process.cwd()}" ROOT="${ROOT}"`);
 		console.log('=======================================================');
-		await oclifRun([packCmd].concat(...packOpts));
+		const oclifPath = path.join(ROOT, 'node_modules', 'oclif');
+		await oclifRun([packCmd].concat(...packOpts), oclifPath);
 		await renameInstallerFiles();
 		// The Windows installer is explicitly signed here (oclif doesn't do it).
 		// The macOS installer is automatically signed by oclif (which runs the

automation/capitanodoc/capitanodoc.ts

@@ -17,6 +17,7 @@
 
 import * as path from 'path';
 import { MarkdownFileParser } from './utils';
+import { GlobSync } from 'glob';
 
 /**
  * This is the skeleton of CLI documentation/reference web page at:
@@ -24,173 +25,114 @@ import { MarkdownFileParser } from './utils';
  *
  * The `getCapitanoDoc` function in this module parses README.md and adds
  * some content to this object.
+ *
+ * IMPORTANT
+ *
+ * All commands need to be stored under a folder in lib/commands to maintain uniformity
+ * Generating docs will error out if directive not followed
+ * To add a custom heading for command docs, add the heading next to the folder name
+ * in the `commandHeadings` dictionary.
+ *
+ * This dictionary is the source of truth that creates the docs config which is used
+ * to generate the CLI documentation. By default, the folder name will be used.
+ *
+ * Resources with plural names needs to have 2 sections if they have commands like:
+ * "fleet, fleets" or "device, devices" or "tag, tags"
+ *
  */
-const capitanoDoc = {
-	title: 'balena CLI Documentation',
-	introduction: '',
-	categories: [
-		{
-			title: 'API keys',
-			files: ['build/commands/api-key/generate.js'],
-		},
-		{
-			title: 'Fleet',
-			files: [
-				'build/commands/fleets.js',
-				'build/commands/fleet/index.js',
-				'build/commands/fleet/create.js',
-				'build/commands/fleet/purge.js',
-				'build/commands/fleet/rename.js',
-				'build/commands/fleet/restart.js',
-				'build/commands/fleet/rm.js',
-			],
-		},
-		{
-			title: 'Authentication',
-			files: [
-				'build/commands/login.js',
-				'build/commands/logout.js',
-				'build/commands/whoami.js',
-			],
-		},
-		{
-			title: 'Device',
-			files: [
-				'build/commands/devices/index.js',
-				'build/commands/devices/supported.js',
-				'build/commands/device/index.js',
-				'build/commands/device/deactivate.js',
-				'build/commands/device/identify.js',
-				'build/commands/device/init.js',
-				'build/commands/device/local-mode.js',
-				'build/commands/device/move.js',
-				'build/commands/device/os-update.js',
-				'build/commands/device/public-url.js',
-				'build/commands/device/purge.js',
-				'build/commands/device/reboot.js',
-				'build/commands/device/register.js',
-				'build/commands/device/rename.js',
-				'build/commands/device/restart.js',
-				'build/commands/device/rm.js',
-				'build/commands/device/shutdown.js',
-			],
-		},
-		{
-			title: 'Releases',
-			files: [
-				'build/commands/releases.js',
-				'build/commands/release/index.js',
-				'build/commands/release/finalize.js',
-			],
-		},
-		{
-			title: 'Environment Variables',
-			files: [
-				'build/commands/envs.js',
-				'build/commands/env/add.js',
-				'build/commands/env/rename.js',
-				'build/commands/env/rm.js',
-			],
-		},
-		{
-			title: 'Tags',
-			files: [
-				'build/commands/tags.js',
-				'build/commands/tag/rm.js',
-				'build/commands/tag/set.js',
-			],
-		},
-		{
-			title: 'Help and Version',
-			files: ['help', 'build/commands/version.js'],
-		},
-		{
-			title: 'Keys',
-			files: [
-				'build/commands/keys.js',
-				'build/commands/key/index.js',
-				'build/commands/key/add.js',
-				'build/commands/key/rm.js',
-			],
-		},
-		{
-			title: 'Logs',
-			files: ['build/commands/logs.js'],
-		},
-		{
-			title: 'Network',
-			files: [
-				'build/commands/scan.js',
-				'build/commands/ssh.js',
-				'build/commands/tunnel.js',
-			],
-		},
-		{
-			title: 'Notes',
-			files: ['build/commands/note.js'],
-		},
-		{
-			title: 'OS',
-			files: [
-				'build/commands/os/build-config.js',
-				'build/commands/os/configure.js',
-				'build/commands/os/versions.js',
-				'build/commands/os/download.js',
-				'build/commands/os/initialize.js',
-			],
-		},
-		{
-			title: 'Config',
-			files: [
-				'build/commands/config/generate.js',
-				'build/commands/config/inject.js',
-				'build/commands/config/read.js',
-				'build/commands/config/reconfigure.js',
-				'build/commands/config/write.js',
-			],
-		},
-		{
-			title: 'Preload',
-			files: ['build/commands/preload.js'],
-		},
-		{
-			title: 'Push',
-			files: ['build/commands/push.js'],
-		},
-		{
-			title: 'Settings',
-			files: ['build/commands/settings.js'],
-		},
-		{
-			title: 'Local',
-			files: [
-				'build/commands/local/configure.js',
-				'build/commands/local/flash.js',
-			],
-		},
-		{
-			title: 'Deploy',
-			files: ['build/commands/build.js', 'build/commands/deploy.js'],
-		},
-		{
-			title: 'Platform',
-			files: ['build/commands/join.js', 'build/commands/leave.js'],
-		},
-		{
-			title: 'Utilities',
-			files: ['build/commands/util/available-drives.js'],
-		},
-		{
-			title: 'Support',
-			files: ['build/commands/support.js'],
-		},
-	],
+
+interface Category {
+	title: string;
+	files: string[];
+}
+
+interface Documentation {
+	title: string;
+	introduction: string;
+	categories: Category[];
+}
+
+// Mapping folders names to custom headings in the docs
+const commandHeadings: { [key: string]: string } = {
+	'api-key': 'API Key',
+	'api-keys': 'API Keys',
+	login: 'Authentication',
+	whoami: 'Authentication',
+	logout: 'Authentication',
+	env: 'Environment Variable',
+	envs: 'Environment Variables',
+	help: 'Help and Version',
+	key: 'SSH Key',
+	keys: 'SSH Keys',
+	orgs: 'Organizations',
+	os: 'OS',
+	util: 'Utilities',
+	ssh: 'Network',
+	scan: 'Network',
+	tunnel: 'Network',
+	build: 'Deploy',
+	join: 'Platform',
+	leave: 'Platform',
 };
 
+// Fetch all available commands
+const allCommandsPaths = new GlobSync('build/commands/**/*.js', {
+	ignore: 'build/commands/internal/**',
+}).found;
+
+// Throw error if any commands found outside of command directories
+const illegalCommandPaths = allCommandsPaths.filter((commandPath: string) =>
+	/^build\/commands\/[^/]+\.js$/.test(commandPath),
+);
+
+if (illegalCommandPaths.length !== 0) {
+	throw new Error(
+		`Found the following commands without a command directory: ${illegalCommandPaths}\n
+		To resolve this error, move the respective commands to their resource directories or create new ones.\n
+		Refer to the automation/capitanodoc/capitanodoc.ts file for more information.`,
+	);
+}
+
+// Docs config template
+const capitanoDoc: Documentation = {
+	title: 'balena CLI Documentation',
+	introduction: '',
+	categories: [],
+};
+
+// Helper function to capitalize each word of directory name
+function formatTitle(dir: string): string {
+	return dir.replace(/(^\w|\s\w)/g, (word) => word.toUpperCase());
+}
+
+// Create a map to track the categories for faster lookup
+const categoriesMap: { [key: string]: Category } = {};
+
+for (const commandPath of allCommandsPaths) {
+	const commandDir = path.basename(path.dirname(commandPath));
+	const heading = commandHeadings[commandDir] || formatTitle(commandDir);
+
+	if (!categoriesMap[heading]) {
+		categoriesMap[heading] = { title: heading, files: [] };
+		capitanoDoc.categories.push(categoriesMap[heading]);
+	}
+
+	categoriesMap[heading].files.push(commandPath);
+}
+
+// Sort Category titles alphabetically
+capitanoDoc.categories = capitanoDoc.categories.sort((a, b) =>
+	a.title.localeCompare(b.title),
+);
+
+// Sort Category file paths alphabetically
+capitanoDoc.categories.forEach((category) => {
+	category.files.sort((a, b) => a.localeCompare(b));
+});
+
 /**
- * Modify and return the `capitanoDoc` object above in order to render the
- * CLI documentation/reference web page at:
- * https://www.balena.io/docs/reference/cli/
+ * Modify and return the `capitanoDoc` object above in order to generate the
+ * CLI documentation at docs/balena-cli.md
  *
  * This function parses the README.md file to extract relevant sections
  * for the documentation web page.

automation/capitanodoc/doc-types.d.ts

@@ -14,7 +14,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { Command as OclifCommandClass } from '@oclif/command';
+import { Command as OclifCommandClass } from '@oclif/core';
 
 type OclifCommand = typeof OclifCommandClass;
 

automation/capitanodoc/index.ts

@@ -62,12 +62,11 @@ class FakeHelpCommand {
 		'$ balena help os download',
 	];
 
-	args = [
-		{
-			name: 'command',
+	args = {
+		command: {
 			description: 'command to show help for',
 		},
-	];
+	};
 
 	usage = 'help [command]';
 
@@ -105,5 +104,5 @@ async function printMarkdown() {
 	}
 }
 
-// tslint:disable-next-line:no-floating-promises
+// eslint-disable-next-line @typescript-eslint/no-floating-promises
 printMarkdown();

automation/capitanodoc/markdown.ts

@@ -14,7 +14,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { flagUsages } from '@oclif/parser';
+import { Parser } from '@oclif/core';
 import * as ent from 'ent';
 import * as _ from 'lodash';
 
@@ -37,8 +37,8 @@ function renderOclifCommand(command: OclifCommand): string[] {
 
 	if (!_.isEmpty(command.args)) {
 		result.push('### Arguments');
-		for (const arg of command.args!) {
-			result.push(`#### ${arg.name.toUpperCase()}`, arg.description || '');
+		for (const [name, arg] of Object.entries(command.args!)) {
+			result.push(`#### ${name.toUpperCase()}`, arg.description || '');
 		}
 	}
 
@@ -49,7 +49,7 @@ function renderOclifCommand(command: OclifCommand): string[] {
 				continue;
 			}
 			flag.name = name;
-			const flagUsage = flagUsages([flag])
+			const flagUsage = Parser.flagUsages([flag])
 				.map(([usage, _description]) => usage)
 				.join()
 				.trim();

automation/check-doc.ts

@@ -15,11 +15,12 @@
  * limitations under the License.
  */
 
-const stripIndent = require('common-tags/lib/stripIndent');
-const _ = require('lodash');
-const { promises: fs } = require('fs');
-const path = require('path');
-const simplegit = require('simple-git/promise');
+// eslint-disable-next-line no-restricted-imports
+import { stripIndent } from 'common-tags';
+import * as _ from 'lodash';
+import { promises as fs } from 'fs';
+import * as path from 'path';
+import { simpleGit } from 'simple-git';
 
 const ROOT = path.normalize(path.join(__dirname, '..'));
 
@@ -31,7 +32,7 @@ const ROOT = path.normalize(path.join(__dirname, '..'));
  * using `touch`.
  */
 async function checkBuildTimestamps() {
-	const git = simplegit(ROOT);
+	const git = simpleGit(ROOT);
 	const docFile = path.join(ROOT, 'docs', 'balena-cli.md');
 	const [docStat, gitStatus] = await Promise.all([
 		fs.stat(docFile),
@@ -81,4 +82,5 @@ async function run() {
 	}
 }
 
+// eslint-disable-next-line @typescript-eslint/no-floating-promises
 run();

automation/check-npm-version.js

@@ -23,8 +23,8 @@ function parseSemver(version) {
  * @param {string} v2
  */
 function semverGte(v1, v2) {
-	let v1Array = parseSemver(v1);
-	let v2Array = parseSemver(v2);
+	const v1Array = parseSemver(v1);
+	const v2Array = parseSemver(v2);
 	for (let i = 0; i < 3; i++) {
 		if (v1Array[i] < v2Array[i]) {
 			return false;

automation/deploy-bin.ts

@@ -30,7 +30,7 @@ const { GITHUB_TOKEN } = process.env;
 export async function createGitHubRelease() {
 	console.log(`Publishing release ${version} to GitHub`);
 	const publishRelease = await import('publish-release');
-	const ghRelease = await Bluebird.fromCallback(
+	const ghRelease = (await Bluebird.fromCallback(
 		publishRelease.bind(null, {
 			token: GITHUB_TOKEN || '',
 			owner: 'balena-io',
@@ -40,7 +40,7 @@ export async function createGitHubRelease() {
 			reuseRelease: true,
 			assets: finalReleaseAssets[process.platform],
 		}),
-	);
+	)) as { html_url: any };
 	console.log(`Release ${version} successful: ${ghRelease.html_url}`);
 }
 
@@ -154,7 +154,7 @@ async function updateGitHubReleaseDescriptions(
 ) {
 	const perPage = 30;
 	const octokit = getOctokit();
-	const options = await octokit.repos.listReleases.endpoint.merge({
+	const options = octokit.repos.listReleases.endpoint.merge({
 		owner,
 		repo,
 		per_page: perPage,

automation/run.ts

@@ -21,6 +21,7 @@ import {
 	buildOclifInstaller,
 	buildStandaloneZip,
 	catchUncommitted,
+	signFilesForNotarization,
 	testShrinkwrap,
 } from './build-bin';
 import {
@@ -54,32 +55,18 @@ async function parse(args?: string[]) {
 	const commands: { [cmd: string]: () => void | Promise<void> } = {
 		'build:installer': buildOclifInstaller,
 		'build:standalone': buildStandaloneZip,
+		'sign:binaries': signFilesForNotarization,
 		'catch-uncommitted': catchUncommitted,
 		'test-shrinkwrap': testShrinkwrap,
 		fix1359: updateDescriptionOfReleasesAffectedByIssue1359,
 		release,
 	};
 	for (const arg of args) {
-		if (!commands.hasOwnProperty(arg)) {
+		if (!Object.hasOwn(commands, arg)) {
 			throw new Error(`command unknown: ${arg}`);
 		}
 	}
 
-	// The BUILD_TMP env var is used as an alternative location for oclif
-	// (patched) to copy/extract the CLI files, run npm install and then
-	// create the NSIS executable installer for Windows. This was necessary
-	// to avoid issues with a 260-char limit on Windows paths (possibly a
-	// limitation of some library used by NSIS), as the "current working dir"
-	// provided by balena CI is a rather long path to start with.
-	if (process.platform === 'win32' && !process.env.BUILD_TMP) {
-		const randID = (await import('crypto'))
-			.randomBytes(6)
-			.toString('base64')
-			.replace(/\+/g, '-')
-			.replace(/\//g, '_'); // base64url (RFC 4648)
-		process.env.BUILD_TMP = `C:\\tmp\\${randID}`;
-	}
-
 	for (const arg of args) {
 		try {
 			const cmdFunc = commands[arg];
@@ -103,5 +90,5 @@ export async function run(args?: string[]) {
 	}
 }
 
-// tslint:disable-next-line:no-floating-promises
+// eslint-disable-next-line @typescript-eslint/no-floating-promises
 run();

automation/update-module.ts

@@ -136,5 +136,5 @@ async function main() {
 	}
 }
 
-// tslint:disable-next-line:no-floating-promises
+// eslint-disable-next-line @typescript-eslint/no-floating-promises
 main();

automation/utils.ts

@@ -16,7 +16,6 @@
  */
 
 import { spawn } from 'child_process';
-import * as _ from 'lodash';
 import * as path from 'path';
 
 export const ROOT = path.join(__dirname, '..');

bin/balena

@@ -1,7 +1,5 @@
 #!/usr/bin/env node
 
-// tslint:disable:no-var-requires
-
 // We boost the threadpool size as ext2fs can deadlock with some
 // operations otherwise, if the pool runs out.
 process.env.UV_THREADPOOL_SIZE = '64';
@@ -17,7 +15,7 @@ async function run() {
 	require('@balena/es-version').set('es2018');
 
 	// Run the CLI
-	await require('../build/app').run();
+	await require('../build/app').run(undefined, { dir: __dirname });
 }
 
 run();

bin/balena-dev

@@ -5,8 +5,6 @@
 // Before opening a PR you should build and test your changes using bin/balena
 // ****************************************************************************
 
-// tslint:disable:no-var-requires
-
 // We boost the threadpool size as ext2fs can deadlock with some
 // operations otherwise, if the pool runs out.
 process.env.UV_THREADPOOL_SIZE = '64';
@@ -59,7 +57,7 @@ require('ts-node').register({
 	project: path.join(rootDir, 'tsconfig.json'),
 	transpileOnly: true,
 });
-require('../lib/app').run();
+require('../lib/app').run(undefined, { dir: __dirname, development: true });
 
 // Modify package.json oclif paths from build/ -> lib/, or vice versa
 function modifyOclifPaths(revert) {

completion/_balena

@@ -8,19 +8,21 @@ _balena() {
   local context state line curcontext="$curcontext"
 
   # Valid top-level completions
-  main_commands=( build deploy envs fleets join keys leave login logout logs note orgs preload push releases scan settings ssh support tags tunnel version whoami api-key config device device devices env fleet fleet internal key key local os release release tag util )
+  main_commands=( api-key api-keys app block build config deploy device device devices env envs fleet fleet fleets internal join key key keys leave local login logout logs notes orgs os preload push release release releases scan settings ssh support tag tags tunnel util version whoami )
   # Sub-completions
-  api_key_cmds=( generate )
+  api_key_cmds=( generate revoke )
+  app_cmds=( create )
+  block_cmds=( create )
   config_cmds=( generate inject read reconfigure write )
-  device_cmds=( deactivate identify init local-mode move os-update public-url purge reboot register rename restart rm shutdown )
+  device_cmds=( deactivate identify init local-mode move os-update pin public-url purge reboot register rename restart rm shutdown start-service stop-service track-fleet )
   devices_cmds=( supported )
   env_cmds=( add rename rm )
-  fleet_cmds=( create purge rename restart rm )
+  fleet_cmds=( create pin purge rename restart rm track-latest )
   internal_cmds=( osinit )
   key_cmds=( add rm )
   local_cmds=( configure flash )
   os_cmds=( build-config configure download initialize versions )
-  release_cmds=( finalize )
+  release_cmds=( finalize invalidate validate )
   tag_cmds=( rm set )
 
 
@@ -43,6 +45,12 @@ _balena_sec_cmds() {
       "api-key")
         _describe -t api_key_cmds 'api-key_cmd' api_key_cmds "$@" && ret=0
       ;;
+      "app")
+        _describe -t app_cmds 'app_cmd' app_cmds "$@" && ret=0
+      ;;
+      "block")
+        _describe -t block_cmds 'block_cmd' block_cmds "$@" && ret=0
+      ;;
       "config")
         _describe -t config_cmds 'config_cmd' config_cmds "$@" && ret=0
       ;;

completion/balena-completion.bash

@@ -7,19 +7,21 @@ _balena_complete()
   local cur prev
 
   # Valid top-level completions
-  main_commands="build deploy envs fleets join keys leave login logout logs note orgs preload push releases scan settings ssh support tags tunnel version whoami api-key config device device devices env fleet fleet internal key key local os release release tag util"
+  main_commands="api-key api-keys app block build config deploy device device devices env envs fleet fleet fleets internal join key key keys leave local login logout logs notes orgs os preload push release release releases scan settings ssh support tag tags tunnel util version whoami"
   # Sub-completions
-  api_key_cmds="generate"
+  api_key_cmds="generate revoke"
+  app_cmds="create"
+  block_cmds="create"
   config_cmds="generate inject read reconfigure write"
-  device_cmds="deactivate identify init local-mode move os-update public-url purge reboot register rename restart rm shutdown"
+  device_cmds="deactivate identify init local-mode move os-update pin public-url purge reboot register rename restart rm shutdown start-service stop-service track-fleet"
   devices_cmds="supported"
   env_cmds="add rename rm"
-  fleet_cmds="create purge rename restart rm"
+  fleet_cmds="create pin purge rename restart rm track-latest"
   internal_cmds="osinit"
   key_cmds="add rm"
   local_cmds="configure flash"
   os_cmds="build-config configure download initialize versions"
-  release_cmds="finalize"
+  release_cmds="finalize invalidate validate"
   tag_cmds="rm set"
 
 
@@ -37,6 +39,12 @@ _balena_complete()
       api-key)
         COMPREPLY=( $(compgen -W "$api_key_cmds" -- $cur) )
         ;;
+      app)
+        COMPREPLY=( $(compgen -W "$app_cmds" -- $cur) )
+        ;;
+      block)
+        COMPREPLY=( $(compgen -W "$block_cmds" -- $cur) )
+        ;;
       config)
         COMPREPLY=( $(compgen -W "$config_cmds" -- $cur) )
         ;;

completion/generate-completion.js

@@ -31,8 +31,8 @@ if (fs.existsSync(commandsFilePath)) {
 
 const commandsJson = JSON.parse(fs.readFileSync(commandsFilePath, 'utf8'));
 
-var mainCommands = [];
-var additionalCommands = [];
+const mainCommands = [];
+const additionalCommands = [];
 for (const key of Object.keys(commandsJson.commands)) {
 	const cmd = key.split(':');
 	if (cmd.length > 1) {
@@ -72,8 +72,8 @@ fs.readFile(bashFilePathIn, 'utf8', function (err, data) {
 		/\$main_commands\$/g,
 		'main_commands="' + mainCommandsStr + '"',
 	);
-	var subCommands = [];
-	var prevElement = additionalCommands[0][0];
+	let subCommands = [];
+	let prevElement = additionalCommands[0][0];
 	additionalCommands.forEach(function (element) {
 		if (element[0] === prevElement) {
 			subCommands.push(element[1]);
@@ -134,8 +134,8 @@ fs.readFile(zshFilePathIn, 'utf8', function (err, data) {
 		/\$main_commands\$/g,
 		'main_commands=( ' + mainCommandsStr + ' )',
 	);
-	var subCommands = [];
-	var prevElement = additionalCommands[0][0];
+	let subCommands = [];
+	let prevElement = additionalCommands[0][0];
 	additionalCommands.forEach(function (element) {
 		if (element[0] === prevElement) {
 			subCommands.push(element[1]);

lib/app.ts

@@ -24,6 +24,7 @@ import {
 } from './preparser';
 import { CliSettings } from './utils/bootstrap';
 import { onceAsync } from './utils/lazy';
+import { run as mainRun, settings } from '@oclif/core';
 
 /**
  * Sentry.io setup
@@ -114,10 +115,16 @@ async function oclifRun(command: string[], options: AppOptions) {
 	}
 
 	const runPromise = (async function (shouldFlush: boolean) {
-		const { CustomMain } = await import('./utils/oclif-utils');
 		let isEEXIT = false;
 		try {
-			await CustomMain.run(command);
+			if (options.development) {
+				// In dev mode -> use ts-node and dev plugins
+				process.env.NODE_ENV = 'development';
+				settings.debug = true;
+			}
+			// For posteriority: We can't use default oclif 'execute' as
+			// We customize error handling and flushing
+			await mainRun(command, options.loadOptions ?? options.dir);
 		} catch (error) {
 			// oclif sometimes exits with ExitError code EEXIT 0 (not an error),
 			// for example the `balena help` command.
@@ -130,7 +137,7 @@ async function oclifRun(command: string[], options: AppOptions) {
 			}
 		}
 		if (shouldFlush) {
-			await import('@oclif/command/flush');
+			await import('@oclif/core/flush');
 		}
 		// TODO: figure out why we need to call fast-boot stop() here, in
 		// addition to calling it in the main `run()` function in this file.
@@ -151,7 +158,7 @@ async function oclifRun(command: string[], options: AppOptions) {
 }
 
 /** CLI entrypoint. Called by the `bin/balena` and `bin/balena-dev` scripts. */
-export async function run(cliArgs = process.argv, options: AppOptions = {}) {
+export async function run(cliArgs = process.argv, options: AppOptions) {
 	try {
 		const { setOfflineModeEnvVars, normalizeEnvVars, pkgExec } = await import(
 			'./utils/bootstrap'

lib/command.ts

@@ -15,7 +15,7 @@
  * limitations under the License.
  */
 
-import Command from '@oclif/command';
+import { Command } from '@oclif/core';
 import {
 	InsufficientPrivilegesError,
 	NotAvailableInOfflineModeError,

lib/commands/api-key/generate.ts

@@ -15,20 +15,12 @@
  * limitations under the License.
  */
 
-import { flags } from '@oclif/command';
+import { Args } from '@oclif/core';
 import Command from '../../command';
 import { ExpectedError } from '../../errors';
 import * as cf from '../../utils/common-flags';
 import { getBalenaSdk, stripIndent } from '../../utils/lazy';
 
-interface FlagsDef {
-	help: void;
-}
-
-interface ArgsDef {
-	name: string;
-}
-
 export default class GenerateCmd extends Command {
 	public static description = stripIndent`
 		Generate a new balenaCloud API key.
@@ -41,24 +33,23 @@ export default class GenerateCmd extends Command {
 `;
 	public static examples = ['$ balena api-key generate "Jenkins Key"'];
 
-	public static args = [
-		{
-			name: 'name',
+	public static args = {
+		name: Args.string({
 			description: 'the API key name',
 			required: true,
-		},
-	];
+		}),
+	};
 
 	public static usage = 'api-key generate <name>';
 
-	public static flags: flags.Input<FlagsDef> = {
+	public static flags = {
 		help: cf.help,
 	};
 
 	public static authenticated = true;
 
 	public async run() {
-		const { args: params } = this.parse<FlagsDef, ArgsDef>(GenerateCmd);
+		const { args: params } = await this.parse(GenerateCmd);
 
 		let key;
 		try {

lib/commands/api-key/revoke.ts

@@ -0,0 +1,67 @@
+/**
+ * @license
+ * Copyright 2016-2020 Balena Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { Args } from '@oclif/core';
+import Command from '../../command';
+import * as cf from '../../utils/common-flags';
+import { getBalenaSdk, stripIndent } from '../../utils/lazy';
+
+export default class RevokeCmd extends Command {
+	public static description = stripIndent`
+		Revoke balenaCloud API keys.
+
+		Revoke balenaCloud API keys with the given
+		comma-separated list of ids.
+
+		The given balenaCloud API keys will no longer be usable.
+`;
+	public static examples = [
+		'$ balena api-key revoke 123',
+		'$ balena api-key revoke 123,124,456',
+	];
+
+	public static args = {
+		ids: Args.string({
+			description: 'the API key ids',
+			required: true,
+		}),
+	};
+
+	public static usage = 'api-key revoke <ids>';
+
+	public static flags = {
+		help: cf.help,
+	};
+
+	public static authenticated = true;
+
+	public async run() {
+		const { args: params } = await this.parse(RevokeCmd);
+
+		const apiKeyIds = params.ids.split(',');
+		if (apiKeyIds.filter((apiKeyId) => !apiKeyId.match(/^\d+$/)).length > 0) {
+			console.log('API key ids must be positive integers');
+			return;
+		}
+		await Promise.all(
+			apiKeyIds.map(
+				async (id) => await getBalenaSdk().models.apiKey.revoke(Number(id)),
+			),
+		);
+		console.log('Successfully revoked the given API keys');
+	}
+}

lib/commands/api-keys/index.ts

@@ -0,0 +1,83 @@
+/**
+ * @license
+ * Copyright 2016-2020 Balena Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { Flags } from '@oclif/core';
+import Command from '../../command';
+import * as cf from '../../utils/common-flags';
+import { getBalenaSdk, getVisuals, stripIndent } from '../../utils/lazy';
+
+export default class ApiKeysCmd extends Command {
+	public static description = stripIndent`
+		Print a list of balenaCloud API keys.
+
+		Print a list of balenaCloud API keys.
+
+		Print a list of balenaCloud API keys for the current user or for a specific fleet with the \`--fleet\` option.
+`;
+	public static examples = ['$ balena api-keys'];
+
+	public static usage = 'api-keys';
+
+	public static flags = {
+		help: cf.help,
+		user: Flags.boolean({
+			char: 'u',
+			description: 'show API keys for your user',
+		}),
+		fleet: cf.fleet,
+	};
+
+	public static authenticated = true;
+
+	public async run() {
+		const { flags: options } = await this.parse(ApiKeysCmd);
+
+		const { getApplication } = await import('../../utils/sdk');
+		const actorId = options.fleet
+			? (
+					await getApplication(getBalenaSdk(), options.fleet, {
+						$select: 'actor',
+					})
+			  ).actor
+			: await getBalenaSdk().auth.getActorId();
+		const keys = await getBalenaSdk().pine.get({
+			resource: 'api_key',
+			options: {
+				$select: ['id', 'created_at', 'name', 'description', 'expiry_date'],
+				$filter: {
+					is_of__actor: actorId,
+					...(options.user
+						? {
+								name: {
+									$ne: null,
+								},
+						  }
+						: {}),
+				},
+				$orderby: 'name asc',
+			},
+		});
+		const fields = ['id', 'name', 'created_at', 'description', 'expiry_date'];
+		const _ = await import('lodash');
+		console.log(
+			getVisuals().table.horizontal(
+				keys.map((key) => _.mapValues(key, (val) => val ?? 'N/a')),
+				fields,
+			),
+		);
+	}
+}

lib/commands/app/create.ts

@@ -0,0 +1,83 @@
+/**
+ * @license
+ * Copyright 2016-2021 Balena Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { Flags, Args } from '@oclif/core';
+
+import Command from '../../command';
+import * as cf from '../../utils/common-flags';
+import { stripIndent } from '../../utils/lazy';
+
+export default class AppCreateCmd extends Command {
+	public static description = stripIndent`
+		Create an app.
+
+		Create a new balena app.
+
+		You can specify the organization the app should belong to using
+		the \`--organization\` option. The organization's handle, not its name,
+		should be provided. Organization handles can be listed with the
+		\`balena orgs\` command.
+
+		The app's default device type is specified with the \`--type\` option.
+		The \`balena devices supported\` command can be used to list the available
+		device types.
+
+		Interactive dropdowns will be shown for selection if no device type or
+		organization is specified and there are multiple options to choose from.
+		If there is a single option to choose from, it will be chosen automatically.
+		This interactive behavior can be disabled by explicitly specifying a device
+		type and organization.
+	`;
+
+	public static examples = [
+		'$ balena app create MyApp',
+		'$ balena app create MyApp --organization mmyorg',
+		'$ balena app create MyApp -o myorg --type raspberry-pi',
+	];
+
+	public static args = {
+		name: Args.string({
+			description: 'app name',
+			required: true,
+		}),
+	};
+
+	public static usage = 'app create <name>';
+
+	public static flags = {
+		organization: Flags.string({
+			char: 'o',
+			description: 'handle of the organization the app should belong to',
+		}),
+		type: Flags.string({
+			char: 't',
+			description:
+				'app device type (Check available types with `balena devices supported`)',
+		}),
+		help: cf.help,
+	};
+
+	public static authenticated = true;
+
+	public async run() {
+		const { args: params, flags: options } = await this.parse(AppCreateCmd);
+
+		await (
+			await import('../../utils/application-create')
+		).applicationCreateBase('app', options, params);
+	}
+}

lib/commands/block/create.ts

@@ -0,0 +1,83 @@
+/**
+ * @license
+ * Copyright 2016-2021 Balena Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { Flags, Args } from '@oclif/core';
+
+import Command from '../../command';
+import * as cf from '../../utils/common-flags';
+import { stripIndent } from '../../utils/lazy';
+
+export default class BlockCreateCmd extends Command {
+	public static description = stripIndent`
+		Create an block.
+
+		Create a new balena block.
+
+		You can specify the organization the block should belong to using
+		the \`--organization\` option. The organization's handle, not its name,
+		should be provided. Organization handles can be listed with the
+		\`balena orgs\` command.
+
+		The block's default device type is specified with the \`--type\` option.
+		The \`balena devices supported\` command can be used to list the available
+		device types.
+
+		Interactive dropdowns will be shown for selection if no device type or
+		organization is specified and there are multiple options to choose from.
+		If there is a single option to choose from, it will be chosen automatically.
+		This interactive behavior can be disabled by explicitly specifying a device
+		type and organization.
+	`;
+
+	public static examples = [
+		'$ balena block create MyBlock',
+		'$ balena block create MyBlock --organization mmyorg',
+		'$ balena block create MyBlock -o myorg --type raspberry-pi',
+	];
+
+	public static args = {
+		name: Args.string({
+			description: 'block name',
+			required: true,
+		}),
+	};
+
+	public static usage = 'block create <name>';
+
+	public static flags = {
+		organization: Flags.string({
+			char: 'o',
+			description: 'handle of the organization the block should belong to',
+		}),
+		type: Flags.string({
+			char: 't',
+			description:
+				'block device type (Check available types with `balena devices supported`)',
+		}),
+		help: cf.help,
+	};
+
+	public static authenticated = true;
+
+	public async run() {
+		const { args: params, flags: options } = await this.parse(BlockCreateCmd);
+
+		await (
+			await import('../../utils/application-create')
+		).applicationCreateBase('block', options, params);
+	}
+}

lib/commands/build/index.ts

@@ -15,22 +15,25 @@
  * limitations under the License.
  */
 
-import { flags } from '@oclif/command';
-import Command from '../command';
-import { getBalenaSdk } from '../utils/lazy';
-import * as cf from '../utils/common-flags';
-import * as compose from '../utils/compose';
-import type { Application, ApplicationType, BalenaSDK } from 'balena-sdk';
+import { Args, Flags } from '@oclif/core';
+import Command from '../../command';
+import { getBalenaSdk } from '../../utils/lazy';
+import * as cf from '../../utils/common-flags';
+import * as compose from '../../utils/compose';
+import type { ApplicationType, BalenaSDK } from 'balena-sdk';
 import {
 	buildArgDeprecation,
 	dockerignoreHelp,
 	registrySecretsHelp,
-} from '../utils/messages';
-import type { ComposeCliFlags, ComposeOpts } from '../utils/compose-types';
-import { buildProject, composeCliFlags } from '../utils/compose_ts';
-import type { BuildOpts, DockerCliFlags } from '../utils/docker';
-import { dockerCliFlags } from '../utils/docker';
+} from '../../utils/messages';
+import type { ComposeCliFlags, ComposeOpts } from '../../utils/compose-types';
+import { buildProject, composeCliFlags } from '../../utils/compose_ts';
+import type { BuildOpts, DockerCliFlags } from '../../utils/docker';
+import { dockerCliFlags } from '../../utils/docker';
 
+// TODO: For this special one we can't use Interfaces.InferredFlags/InferredArgs
+// because of the 'registry-secrets' type which is defined in the actual code
+// as a path (string | undefined) but then the cli turns it into an object
 interface FlagsDef extends ComposeCliFlags, DockerCliFlags {
 	arch?: string;
 	deviceType?: string;
@@ -39,10 +42,6 @@ interface FlagsDef extends ComposeCliFlags, DockerCliFlags {
 	help: void;
 }
 
-interface ArgsDef {
-	source?: string;
-}
-
 export default class BuildCmd extends Command {
 	public static description = `\
 Build a project locally.
@@ -74,21 +73,18 @@ ${dockerignoreHelp}
 		'$ balena build --dockerHost my.docker.host --dockerPort 2376 --ca ca.pem --key key.pem --cert cert.pem -f myFleet',
 	];
 
-	public static args = [
-		{
-			name: 'source',
-			description: 'path of project source directory',
-		},
-	];
+	public static args = {
+		source: Args.string({ description: 'path of project source directory' }),
+	};
 
 	public static usage = 'build [source]';
 
-	public static flags: flags.Input<FlagsDef> = {
-		arch: flags.string({
+	public static flags = {
+		arch: Flags.string({
 			description: 'the architecture to build for',
 			char: 'A',
 		}),
-		deviceType: flags.string({
+		deviceType: Flags.string({
 			description: 'the type of device this build is for',
 			char: 'd',
 		}),
@@ -97,15 +93,13 @@ ${dockerignoreHelp}
 		...dockerCliFlags,
 		// NOTE: Not supporting -h for help, because of clash with -h in DockerCliFlags
 		// Revisit this in future release.
-		help: flags.help({}),
+		help: Flags.help({}),
 	};
 
 	public static primary = true;
 
 	public async run() {
-		const { args: params, flags: options } = this.parse<FlagsDef, ArgsDef>(
-			BuildCmd,
-		);
+		const { args: params, flags: options } = await this.parse(BuildCmd);
 
 		await Command.checkLoggedInIf(!!options.fleet);
 
@@ -154,14 +148,14 @@ ${dockerignoreHelp}
 			(opts.fleet == null && (opts.arch == null || opts.deviceType == null)) ||
 			(opts.fleet != null && (opts.arch != null || opts.deviceType != null))
 		) {
-			const { ExpectedError } = await import('../errors');
+			const { ExpectedError } = await import('../../errors');
 			throw new ExpectedError(
 				'You must specify either a fleet (-f), or the device type (-d) and architecture (-A)',
 			);
 		}
 
 		// Validate project directory
-		const { validateProjectDirectory } = await import('../utils/compose_ts');
+		const { validateProjectDirectory } = await import('../../utils/compose_ts');
 		const { dockerfilePath, registrySecrets } = await validateProjectDirectory(
 			sdk,
 			{
@@ -178,7 +172,7 @@ ${dockerignoreHelp}
 
 	protected async getAppAndResolveArch(opts: FlagsDef) {
 		if (opts.fleet) {
-			const { getAppWithArch } = await import('../utils/helpers');
+			const { getAppWithArch } = await import('../../utils/helpers');
 			const app = await getAppWithArch(opts.fleet);
 			opts.arch = app.arch;
 			opts.deviceType = app.is_for__device_type[0].slug;
@@ -187,7 +181,7 @@ ${dockerignoreHelp}
 	}
 
 	protected async prepareBuild(options: FlagsDef) {
-		const { getDocker, generateBuildOpts } = await import('../utils/docker');
+		const { getDocker, generateBuildOpts } = await import('../../utils/docker');
 		const [docker, buildOpts, composeOpts] = await Promise.all([
 			getDocker(options),
 			generateBuildOpts(options),
@@ -208,24 +202,26 @@ ${dockerignoreHelp}
 	 *   buildEmulated
 	 *   buildOpts: arguments to forward to docker build command
 	 *
-	 * @param {DockerToolbelt} docker
+	 * @param {Dockerode} docker
 	 * @param {Logger} logger
 	 * @param {ComposeOpts} composeOpts
 	 * @param opts
 	 */
 	protected async buildProject(
 		docker: import('dockerode'),
-		logger: import('../utils/logger'),
+		logger: import('../../utils/logger'),
 		composeOpts: ComposeOpts,
 		opts: {
-			app?: Application;
+			app?: {
+				application_type: [Pick<ApplicationType, 'supports_multicontainer'>];
+			};
 			arch: string;
 			deviceType: string;
 			buildEmulated: boolean;
 			buildOpts: BuildOpts;
 		},
 	) {
-		const { loadProject } = await import('../utils/compose_ts');
+		const { loadProject } = await import('../../utils/compose_ts');
 
 		const project = await loadProject(
 			logger,
@@ -234,7 +230,7 @@ ${dockerignoreHelp}
 			opts.buildOpts.t,
 		);
 
-		const appType = (opts.app?.application_type as ApplicationType[])?.[0];
+		const appType = opts.app?.application_type?.[0];
 		if (
 			appType != null &&
 			project.descriptors.length > 1 &&

lib/commands/config/generate.ts

@@ -15,30 +15,17 @@
  * limitations under the License.
  */
 
-import { flags } from '@oclif/command';
+import { Flags } from '@oclif/core';
+import type { Interfaces } from '@oclif/core';
 import Command from '../../command';
 import * as cf from '../../utils/common-flags';
 import { getBalenaSdk, getCliForm, stripIndent } from '../../utils/lazy';
-import { applicationIdInfo, devModeInfo } from '../../utils/messages';
-import type { PineDeferred } from 'balena-sdk';
-
-interface FlagsDef {
-	version: string; // OS version
-	fleet?: string;
-	dev?: boolean; // balenaOS development variant
-	device?: string;
-	deviceApiKey?: string;
-	deviceType?: string;
-	'generate-device-api-key': boolean;
-	output?: string;
-	// Options for non-interactive configuration
-	network?: string;
-	wifiSsid?: string;
-	wifiKey?: string;
-	appUpdatePollInterval?: string;
-	'provisioning-key-name'?: string;
-	help: void;
-}
+import {
+	applicationIdInfo,
+	devModeInfo,
+	secureBootInfo,
+} from '../../utils/messages';
+import type { BalenaSDK, PineDeferred } from 'balena-sdk';
 
 export default class ConfigGenerateCmd extends Command {
 	public static description = stripIndent`
@@ -50,6 +37,8 @@ export default class ConfigGenerateCmd extends Command {
 
 		${devModeInfo.split('\n').join('\n\t\t')}
 
+		${secureBootInfo.split('\n').join('\n\t\t')}
+
 		To configure an image for a fleet of mixed device types, use the --fleet option
 		alongside the --deviceType option to specify the target device type.
 
@@ -65,6 +54,7 @@ export default class ConfigGenerateCmd extends Command {
 		'$ balena config generate --device 7cf02a6 --version 2.12.7 --deviceApiKey <existingDeviceKey>',
 		'$ balena config generate --device 7cf02a6 --version 2.12.7 --output config.json',
 		'$ balena config generate --fleet myorg/fleet --version 2.12.7 --dev',
+		'$ balena config generate --fleet myorg/fleet --version 2.12.7 --secureBoot',
 		'$ balena config generate --fleet myorg/fleet --version 2.12.7 --deviceType fincm3',
 		'$ balena config generate --fleet myorg/fleet --version 2.12.7 --output config.json',
 		'$ balena config generate --fleet myorg/fleet --version 2.12.7 --network wifi --wifiSsid mySsid --wifiKey abcdefgh --appUpdatePollInterval 15',
@@ -72,79 +62,95 @@ export default class ConfigGenerateCmd extends Command {
 
 	public static usage = 'config generate';
 
-	public static flags: flags.Input<FlagsDef> = {
-		version: flags.string({
+	public static flags = {
+		version: Flags.string({
 			description: 'a balenaOS version',
 			required: true,
 		}),
 		fleet: { ...cf.fleet, exclusive: ['device'] },
 		dev: cf.dev,
+		secureBoot: cf.secureBoot,
 		device: {
 			...cf.device,
-			exclusive: ['fleet', 'provisioning-key-name'],
+			exclusive: [
+				'fleet',
+				'provisioning-key-name',
+				'provisioning-key-expiry-date',
+			],
 		},
-		deviceApiKey: flags.string({
+		deviceApiKey: Flags.string({
 			description:
 				'custom device key - note that this is only supported on balenaOS 2.0.3+',
 			char: 'k',
 		}),
-		deviceType: flags.string({
+		deviceType: Flags.string({
 			description:
 				"device type slug (run 'balena devices supported' for possible values)",
 		}),
-		'generate-device-api-key': flags.boolean({
+		'generate-device-api-key': Flags.boolean({
 			description: 'generate a fresh device key for the device',
 		}),
-		output: flags.string({
+		output: Flags.string({
 			description: 'path of output file',
 			char: 'o',
 		}),
 		// Options for non-interactive configuration
-		network: flags.string({
+		network: Flags.string({
 			description: 'the network type to use: ethernet or wifi',
 			options: ['ethernet', 'wifi'],
 		}),
-		wifiSsid: flags.string({
+		wifiSsid: Flags.string({
 			description:
 				'the wifi ssid to use (used only if --network is set to wifi)',
 		}),
-		wifiKey: flags.string({
+		wifiKey: Flags.string({
 			description:
 				'the wifi key to use (used only if --network is set to wifi)',
 		}),
-		appUpdatePollInterval: flags.string({
+		appUpdatePollInterval: Flags.string({
 			description:
 				'supervisor cloud polling interval in minutes (e.g. for device variables)',
 		}),
-		'provisioning-key-name': flags.string({
+		'provisioning-key-name': Flags.string({
 			description: 'custom key name assigned to generated provisioning api key',
 			exclusive: ['device'],
 		}),
+		'provisioning-key-expiry-date': Flags.string({
+			description:
+				'expiry date assigned to generated provisioning api key (format: YYYY-MM-DD)',
+			exclusive: ['device'],
+		}),
 		help: cf.help,
 	};
 
 	public static authenticated = true;
 
-	public async run() {
-		const { flags: options } = this.parse<FlagsDef, {}>(ConfigGenerateCmd);
-
+	public async getApplication(balena: BalenaSDK, fleet: string) {
 		const { getApplication } = await import('../../utils/sdk');
+		return await getApplication(balena, fleet, {
+			$select: 'slug',
+			$expand: {
+				is_for__device_type: { $select: 'slug' },
+			},
+		});
+	}
 
+	public async run() {
+		const { flags: options } = await this.parse(ConfigGenerateCmd);
 		const balena = getBalenaSdk();
 
 		await this.validateOptions(options);
 
 		let resourceDeviceType: string;
-		let application: ApplicationWithDeviceType | null = null;
+		let application: Awaited<ReturnType<typeof this.getApplication>> | null =
+			null;
 		let device:
 			| (DeviceWithDeviceType & { belongs_to__application: PineDeferred })
 			| null = null;
 		if (options.device != null) {
-			const { tryAsInteger } = await import('../../utils/validation');
-			const rawDevice = await balena.models.device.get(
-				tryAsInteger(options.device),
-				{ $expand: { is_of__device_type: { $select: 'slug' } } },
-			);
+			const rawDevice = await balena.models.device.get(options.device, {
+				$expand: { is_of__device_type: { $select: 'slug' } },
+			});
 			if (!rawDevice.belongs_to__application) {
 				const { ExpectedError } = await import('../../errors');
 				throw new ExpectedError(stripIndent`
@@ -157,36 +163,40 @@ export default class ConfigGenerateCmd extends Command {
 			resourceDeviceType = device.is_of__device_type[0].slug;
 		} else {
 			// Disambiguate application (if is a number, it could either be an ID or a numerical name)
-			application = (await getApplication(balena, options.fleet!, {
-				$expand: {
-					is_for__device_type: { $select: 'slug' },
-				},
-			})) as ApplicationWithDeviceType;
+			application = await this.getApplication(balena, options.fleet!);
 			resourceDeviceType = application.is_for__device_type[0].slug;
 		}
 
 		const deviceType = options.deviceType || resourceDeviceType;
 
-		const deviceManifest = await balena.models.device.getManifestBySlug(
-			deviceType,
-		);
-
 		// Check compatibility if application and deviceType provided
 		if (options.fleet && options.deviceType) {
-			const appDeviceManifest = await balena.models.device.getManifestBySlug(
-				resourceDeviceType,
-			);
-
 			const helpers = await import('../../utils/helpers');
 			if (
-				!helpers.areDeviceTypesCompatible(appDeviceManifest, deviceManifest)
+				!(await helpers.areDeviceTypesCompatible(
+					resourceDeviceType,
+					deviceType,
+				))
 			) {
-				throw new balena.errors.BalenaInvalidDeviceType(
+				const { ExpectedError } = await import('../../errors');
+				throw new ExpectedError(
 					`Device type ${options.deviceType} is incompatible with fleet ${options.fleet}`,
 				);
 			}
 		}
 
+		const deviceManifest =
+			await balena.models.config.getDeviceTypeManifestBySlug(deviceType);
+
+		const { validateSecureBootOptionAndWarn } = await import(
+			'../../utils/config'
+		);
+		await validateSecureBootOptionAndWarn(
+			options.secureBoot,
+			deviceType,
+			options.version,
+		);
+
 		// Prompt for values
 		// Pass params as an override: if there is any param with exactly the same name as a
 		// required option, that value is used (and the corresponding question is not asked)
@@ -195,7 +205,9 @@ export default class ConfigGenerateCmd extends Command {
 		});
 		answers.version = options.version;
 		answers.developmentMode = options.dev;
+		answers.secureBoot = options.secureBoot;
 		answers.provisioningKeyName = options['provisioning-key-name'];
+		answers.provisioningKeyExpiryDate = options['provisioning-key-expiry-date'];
 
 		// Generate config
 		const { generateDeviceConfig, generateApplicationConfig } = await import(
@@ -235,7 +247,9 @@ export default class ConfigGenerateCmd extends Command {
 	protected readonly deviceTypeNotAllowedMessage =
 		'The --deviceType option can only be used alongside the --fleet option';
 
-	protected async validateOptions(options: FlagsDef) {
+	protected async validateOptions(
+		options: Interfaces.InferredFlags<typeof ConfigGenerateCmd.flags>,
+	) {
 		const { ExpectedError } = await import('../../errors');
 
 		if (options.device == null && options.fleet == null) {
@@ -245,6 +259,8 @@ export default class ConfigGenerateCmd extends Command {
 		if (!options.fleet && options.deviceType) {
 			throw new ExpectedError(this.deviceTypeNotAllowedMessage);
 		}
+		const { normalizeOsVersion } = await import('../../utils/normalization');
+		options.version = normalizeOsVersion(options.version);
 		const { validateDevOptionAndWarn } = await import('../../utils/config');
 		await validateDevOptionAndWarn(options.dev, options.version);
 	}

lib/commands/config/inject.ts

@@ -15,21 +15,11 @@
  * limitations under the License.
  */
 
-import { flags } from '@oclif/command';
+import { Args } from '@oclif/core';
 import Command from '../../command';
 import * as cf from '../../utils/common-flags';
 import { getVisuals, stripIndent } from '../../utils/lazy';
 
-interface FlagsDef {
-	type?: string;
-	drive?: string;
-	help: void;
-}
-
-interface ArgsDef {
-	file: string;
-}
-
 export default class ConfigInjectCmd extends Command {
 	public static description = stripIndent`
 		Inject a config.json file to a balenaOS image or attached media.
@@ -46,18 +36,16 @@ export default class ConfigInjectCmd extends Command {
 		'$ balena config inject my/config.json --drive /dev/disk2',
 	];
 
-	public static args = [
-		{
-			name: 'file',
+	public static args = {
+		file: Args.string({
 			description: 'the path to the config.json file to inject',
 			required: true,
-		},
-	];
+		}),
+	};
 
 	public static usage = 'config inject <file>';
 
-	public static flags: flags.Input<FlagsDef> = {
-		...cf.deviceTypeIgnored,
+	public static flags = {
 		drive: cf.driveOrImg,
 		help: cf.help,
 	};
@@ -66,9 +54,7 @@ export default class ConfigInjectCmd extends Command {
 	public static offlineCompatible = true;
 
 	public async run() {
-		const { args: params, flags: options } = this.parse<FlagsDef, ArgsDef>(
-			ConfigInjectCmd,
-		);
+		const { args: params, flags: options } = await this.parse(ConfigInjectCmd);
 
 		const { safeUmount } = await import('../../utils/umount');
 

lib/commands/config/read.ts

@@ -15,18 +15,10 @@
  * limitations under the License.
  */
 
-import { flags } from '@oclif/command';
 import Command from '../../command';
 import * as cf from '../../utils/common-flags';
 import { getVisuals, stripIndent } from '../../utils/lazy';
 
-interface FlagsDef {
-	type?: string;
-	drive?: string;
-	help: void;
-	json: boolean;
-}
-
 export default class ConfigReadCmd extends Command {
 	public static description = stripIndent`
 		Read the config.json file of a balenaOS image or attached media.
@@ -46,8 +38,7 @@ export default class ConfigReadCmd extends Command {
 
 	public static usage = 'config read';
 
-	public static flags: flags.Input<FlagsDef> = {
-		...cf.deviceTypeIgnored,
+	public static flags = {
 		drive: cf.driveOrImg,
 		help: cf.help,
 		json: cf.json,
@@ -57,7 +48,7 @@ export default class ConfigReadCmd extends Command {
 	public static offlineCompatible = true;
 
 	public async run() {
-		const { flags: options } = this.parse<FlagsDef, {}>(ConfigReadCmd);
+		const { flags: options } = await this.parse(ConfigReadCmd);
 
 		const { safeUmount } = await import('../../utils/umount');
 

lib/commands/config/reconfigure.ts

@@ -15,19 +15,11 @@
  * limitations under the License.
  */
 
-import { flags } from '@oclif/command';
+import { Flags } from '@oclif/core';
 import Command from '../../command';
 import * as cf from '../../utils/common-flags';
 import { getVisuals, stripIndent } from '../../utils/lazy';
 
-interface FlagsDef {
-	type?: string;
-	drive?: string;
-	advanced: boolean;
-	help: void;
-	version?: string;
-}
-
 export default class ConfigReconfigureCmd extends Command {
 	public static description = stripIndent`
 		Interactively reconfigure a balenaOS image file or attached media.
@@ -49,15 +41,14 @@ export default class ConfigReconfigureCmd extends Command {
 
 	public static usage = 'config reconfigure';
 
-	public static flags: flags.Input<FlagsDef> = {
-		...cf.deviceTypeIgnored,
+	public static flags = {
 		drive: cf.driveOrImg,
-		advanced: flags.boolean({
+		advanced: Flags.boolean({
 			description: 'show advanced commands',
 			char: 'v',
 		}),
 		help: cf.help,
-		version: flags.string({
+		version: Flags.string({
 			description: 'balenaOS version, for example "2.32.0" or "2.44.0+rev1"',
 		}),
 	};
@@ -66,7 +57,7 @@ export default class ConfigReconfigureCmd extends Command {
 	public static root = true;
 
 	public async run() {
-		const { flags: options } = this.parse<FlagsDef, {}>(ConfigReconfigureCmd);
+		const { flags: options } = await this.parse(ConfigReconfigureCmd);
 
 		const { safeUmount } = await import('../../utils/umount');
 

lib/commands/config/write.ts

@@ -15,22 +15,11 @@
  * limitations under the License.
  */
 
-import { flags } from '@oclif/command';
+import { Args } from '@oclif/core';
 import Command from '../../command';
 import * as cf from '../../utils/common-flags';
 import { getVisuals, stripIndent } from '../../utils/lazy';
 
-interface FlagsDef {
-	type?: string;
-	drive?: string;
-	help: void;
-}
-
-interface ArgsDef {
-	key: string;
-	value: string;
-}
-
 export default class ConfigWriteCmd extends Command {
 	public static description = stripIndent`
 		Write a key-value pair to the config.json file of an OS image or attached media.
@@ -48,23 +37,20 @@ export default class ConfigWriteCmd extends Command {
 		'$ balena config write --drive balena.img os.network.connectivity.interval 300',
 	];
 
-	public static args = [
-		{
-			name: 'key',
+	public static args = {
+		key: Args.string({
 			description: 'the key of the config parameter to write',
 			required: true,
-		},
-		{
-			name: 'value',
+		}),
+		value: Args.string({
 			description: 'the value of the config parameter to write',
 			required: true,
-		},
-	];
+		}),
+	};
 
 	public static usage = 'config write <key> <value>';
 
-	public static flags: flags.Input<FlagsDef> = {
-		...cf.deviceTypeIgnored,
+	public static flags = {
 		drive: cf.driveOrImg,
 		help: cf.help,
 	};
@@ -73,9 +59,7 @@ export default class ConfigWriteCmd extends Command {
 	public static offlineCompatible = true;
 
 	public async run() {
-		const { args: params, flags: options } = this.parse<FlagsDef, ArgsDef>(
-			ConfigWriteCmd,
-		);
+		const { args: params, flags: options } = await this.parse(ConfigWriteCmd);
 
 		const { denyMount, safeUmount } = await import('../../utils/umount');
 

lib/commands/deploy/index.ts

@@ -15,59 +15,56 @@
  * limitations under the License.
  */
 
-import { flags } from '@oclif/command';
-import type { ImageDescriptor } from 'resin-compose-parse';
+import { Args, Flags } from '@oclif/core';
+import type { ImageDescriptor } from '@balena/compose/dist/parse';
 
-import Command from '../command';
-import { ExpectedError } from '../errors';
-import { getBalenaSdk, getChalk, stripIndent } from '../utils/lazy';
+import Command from '../../command';
+import { ExpectedError } from '../../errors';
+import { getBalenaSdk, getChalk, stripIndent } from '../../utils/lazy';
 import {
 	dockerignoreHelp,
 	registrySecretsHelp,
 	buildArgDeprecation,
-} from '../utils/messages';
-import * as ca from '../utils/common-args';
-import * as compose from '../utils/compose';
+} from '../../utils/messages';
+import * as ca from '../../utils/common-args';
+import * as compose from '../../utils/compose';
 import type {
 	BuiltImage,
 	ComposeCliFlags,
 	ComposeOpts,
 	Release as ComposeReleaseInfo,
-} from '../utils/compose-types';
-import type { BuildOpts, DockerCliFlags } from '../utils/docker';
+} from '../../utils/compose-types';
+import type { BuildOpts, DockerCliFlags } from '../../utils/docker';
 import {
 	applyReleaseTagKeysAndValues,
 	buildProject,
 	composeCliFlags,
 	isBuildConfig,
 	parseReleaseTagKeysAndValues,
-} from '../utils/compose_ts';
-import { dockerCliFlags } from '../utils/docker';
-import type {
-	Application,
-	ApplicationType,
-	DeviceType,
-	Release,
-} from 'balena-sdk';
+} from '../../utils/compose_ts';
+import { dockerCliFlags } from '../../utils/docker';
+import type { ApplicationType, DeviceType, Release } from 'balena-sdk';
 
-interface ApplicationWithArch extends Application {
+interface ApplicationWithArch {
+	id: number;
 	arch: string;
+	is_for__device_type: [Pick<DeviceType, 'slug'>];
+	application_type: [Pick<ApplicationType, 'slug' | 'supports_multicontainer'>];
 }
 
+// TODO: For this special one we can't use Interfaces.InferredFlags/InferredArgs
+// because of the 'registry-secrets' type which is defined in the actual code
+// as a path (string | undefined) but then the cli turns it into an object
 interface FlagsDef extends ComposeCliFlags, DockerCliFlags {
 	source?: string;
 	build: boolean;
 	nologupload: boolean;
 	'release-tag'?: string[];
 	draft: boolean;
+	note?: string;
 	help: void;
 }
 
-interface ArgsDef {
-	fleet: string;
-	image?: string;
-}
-
 export default class DeployCmd extends Command {
 	public static description = `\
 Deploy a single image or a multicontainer project to a balena fleet.
@@ -101,35 +98,33 @@ ${dockerignoreHelp}
 	public static examples = [
 		'$ balena deploy myFleet',
 		'$ balena deploy myorg/myfleet --build --source myBuildDir/',
+		'$ balena deploy myorg/myfleet --build --source myBuildDir/ --note "this is the note for this release"',
 		'$ balena deploy myorg/myfleet myRepo/myImage',
 		'$ balena deploy myFleet myRepo/myImage --release-tag key1 "" key2 "value2 with spaces"',
 	];
 
-	public static args = [
-		ca.fleetRequired,
-		{
-			name: 'image',
-			description: 'the image to deploy',
-		},
-	];
+	public static args = {
+		fleet: ca.fleetRequired,
+		image: Args.string({ description: 'the image to deploy' }),
+	};
 
 	public static usage = 'deploy <fleet> [image]';
-	// TODO:  docker-compose naming
-	public static flags: flags.Input<FlagsDef> = {
-		source: flags.string({
+
+	public static flags = {
+		source: Flags.string({
 			description:
 				'specify an alternate source directory; default is the working directory',
 			char: 's',
 		}),
-		build: flags.boolean({
+		build: Flags.boolean({
 			description: 'force a rebuild before deploy',
 			char: 'b',
 		}),
-		nologupload: flags.boolean({
+		nologupload: Flags.boolean({
 			description:
 				"don't upload build logs to the dashboard with image (if building)",
 		}),
-		'release-tag': flags.string({
+		'release-tag': Flags.string({
 			description: stripIndent`
 				Set release tags if the image deployment is successful. Multiple
 				arguments may be provided, alternating tag keys and values (see examples).
@@ -137,7 +132,7 @@ ${dockerignoreHelp}
 			`,
 			multiple: true,
 		}),
-		draft: flags.boolean({
+		draft: Flags.boolean({
 			description: stripIndent`
 				Deploy the release as a draft. Draft releases are ignored
 				by the 'track latest' release policy but can be used through release pinning.
@@ -145,11 +140,12 @@ ${dockerignoreHelp}
 				as final by default unless this option is given.`,
 			default: false,
 		}),
+		note: Flags.string({ description: 'The notes for this release' }),
 		...composeCliFlags,
 		...dockerCliFlags,
 		// NOTE: Not supporting -h for help, because of clash with -h in DockerCliFlags
 		// Revisit this in future release.
-		help: flags.help({}),
+		help: Flags.help({}),
 	};
 
 	public static authenticated = true;
@@ -157,9 +153,7 @@ ${dockerignoreHelp}
 	public static primary = true;
 
 	public async run() {
-		const { args: params, flags: options } = this.parse<FlagsDef, ArgsDef>(
-			DeployCmd,
-		);
+		const { args: params, flags: options } = await this.parse(DeployCmd);
 
 		(await import('events')).defaultMaxListeners = 1000;
 
@@ -181,7 +175,7 @@ ${dockerignoreHelp}
 
 		const sdk = getBalenaSdk();
 		const { getRegistrySecrets, validateProjectDirectory } = await import(
-			'../utils/compose_ts'
+			'../../utils/compose_ts'
 		);
 
 		const { releaseTagKeys, releaseTagValues } = parseReleaseTagKeysAndValues(
@@ -189,7 +183,7 @@ ${dockerignoreHelp}
 		);
 
 		if (image) {
-			options['registry-secrets'] = await getRegistrySecrets(
+			(options as FlagsDef)['registry-secrets'] = await getRegistrySecrets(
 				sdk,
 				options['registry-secrets'],
 			);
@@ -202,16 +196,16 @@ ${dockerignoreHelp}
 					registrySecretsPath: options['registry-secrets'],
 				});
 			options.dockerfile = dockerfilePath;
-			options['registry-secrets'] = registrySecrets;
+			(options as FlagsDef)['registry-secrets'] = registrySecrets;
 		}
 
-		const helpers = await import('../utils/helpers');
+		const helpers = await import('../../utils/helpers');
 		const app = await helpers.getAppWithArch(fleet);
 
-		const dockerUtils = await import('../utils/docker');
+		const dockerUtils = await import('../../utils/docker');
 		const [docker, buildOpts, composeOpts] = await Promise.all([
 			dockerUtils.getDocker(options),
-			dockerUtils.generateBuildOpts(options),
+			dockerUtils.generateBuildOpts(options as FlagsDef),
 			compose.generateOpts(options),
 		]);
 
@@ -231,11 +225,14 @@ ${dockerignoreHelp}
 			releaseTagKeys,
 			releaseTagValues,
 		);
+		if (options.note) {
+			await sdk.models.release.setNote(release.id, options.note);
+		}
 	}
 
 	async deployProject(
 		docker: import('dockerode'),
-		logger: import('../utils/logger'),
+		logger: import('../../utils/logger'),
 		composeOpts: ComposeOpts,
 		opts: {
 			app: ApplicationWithArch; // the application instance to deploy to
@@ -253,10 +250,10 @@ ${dockerignoreHelp}
 		const doodles = await import('resin-doodles');
 		const sdk = getBalenaSdk();
 		const { deployProject: $deployProject, loadProject } = await import(
-			'../utils/compose_ts'
+			'../../utils/compose_ts'
 		);
 
-		const appType = (opts.app?.application_type as ApplicationType[])?.[0];
+		const appType = opts.app.application_type[0];
 
 		try {
 			const project = await loadProject(
@@ -313,7 +310,7 @@ ${dockerignoreHelp}
 					projectName: project.name,
 					composition: compositionToBuild,
 					arch: opts.app.arch,
-					deviceType: (opts.app?.is_for__device_type as DeviceType[])?.[0].slug,
+					deviceType: opts.app.is_for__device_type[0].slug,
 					emulated: opts.buildEmulated,
 					buildOpts: opts.buildOpts,
 					inlineLogs: composeOpts.inlineLogs,
@@ -334,17 +331,17 @@ ${dockerignoreHelp}
 			);
 
 			let release: Release | ComposeReleaseInfo['release'];
-			if (appType?.is_legacy) {
-				const { deployLegacy } = require('../utils/deploy-legacy');
+			if (appType.slug === 'legacy-v1' || appType.slug === 'legacy-v2') {
+				const { deployLegacy } = require('../../utils/deploy-legacy');
 
 				const msg = getChalk().yellow(
 					'Target fleet requires legacy deploy method.',
 				);
 				logger.logWarn(msg);
 
-				const [token, username, url, options] = await Promise.all([
+				const [token, { username }, url, options] = await Promise.all([
 					sdk.auth.getToken(),
-					sdk.auth.whoami(),
+					sdk.auth.getUserInfo(),
 					sdk.settings.get('balenaUrl'),
 					{
 						// opts.appName may be prefixed by 'owner/', unlike opts.app.app_name
@@ -367,8 +364,8 @@ ${dockerignoreHelp}
 					$select: ['commit'],
 				});
 			} else {
-				const [userId, auth, apiEndpoint] = await Promise.all([
-					sdk.auth.getUserId(),
+				const [{ id: userId }, auth, apiEndpoint] = await Promise.all([
+					sdk.auth.getUserInfo(),
 					sdk.auth.getToken(),
 					sdk.settings.get('apiUrl'),
 				]);

lib/commands/device/deactivate.ts

@@ -15,21 +15,11 @@
  * limitations under the License.
  */
 
-import { flags } from '@oclif/command';
-import type { IArg } from '@oclif/parser/lib/args';
+import { Args } from '@oclif/core';
 import Command from '../../command';
 import * as cf from '../../utils/common-flags';
 import { getBalenaSdk, stripIndent } from '../../utils/lazy';
 
-interface FlagsDef {
-	yes: boolean;
-	help: void;
-}
-
-interface ArgsDef {
-	uuid: string;
-}
-
 export default class DeviceDeactivateCmd extends Command {
 	public static description = stripIndent`
 		Deactivate a device.
@@ -44,17 +34,16 @@ export default class DeviceDeactivateCmd extends Command {
 		'$ balena device deactivate 7cf02a6 --yes',
 	];
 
-	public static args: Array<IArg<any>> = [
-		{
-			name: 'uuid',
+	public static args = {
+		uuid: Args.string({
 			description: 'the UUID of the device to be deactivated',
 			required: true,
-		},
-	];
+		}),
+	};
 
 	public static usage = 'device deactivate <uuid>';
 
-	public static flags: flags.Input<FlagsDef> = {
+	public static flags = {
 		yes: cf.yes,
 		help: cf.help,
 	};
@@ -62,9 +51,8 @@ export default class DeviceDeactivateCmd extends Command {
 	public static authenticated = true;
 
 	public async run() {
-		const { args: params, flags: options } = this.parse<FlagsDef, ArgsDef>(
-			DeviceDeactivateCmd,
-		);
+		const { args: params, flags: options } =
+			await this.parse(DeviceDeactivateCmd);
 
 		const balena = getBalenaSdk();
 		const patterns = await import('../../utils/patterns');

lib/commands/device/identify.ts

@@ -15,22 +15,12 @@
  * limitations under the License.
  */
 
-import { flags } from '@oclif/command';
-import type { IArg } from '@oclif/parser/lib/args';
+import { Args } from '@oclif/core';
 import Command from '../../command';
 import * as cf from '../../utils/common-flags';
 import { getBalenaSdk, stripIndent } from '../../utils/lazy';
-import { tryAsInteger } from '../../utils/validation';
 import { ExpectedError } from '../../errors';
 
-interface FlagsDef {
-	help: void;
-}
-
-interface ArgsDef {
-	uuid: string;
-}
-
 export default class DeviceIdentifyCmd extends Command {
 	public static description = stripIndent`
 		Identify a device.
@@ -39,25 +29,23 @@ export default class DeviceIdentifyCmd extends Command {
 		`;
 	public static examples = ['$ balena device identify 23c73a1'];
 
-	public static args: Array<IArg<any>> = [
-		{
-			name: 'uuid',
+	public static args = {
+		uuid: Args.string({
 			description: 'the uuid of the device to identify',
-			parse: (dev) => tryAsInteger(dev),
 			required: true,
-		},
-	];
+		}),
+	};
 
 	public static usage = 'device identify <uuid>';
 
-	public static flags: flags.Input<FlagsDef> = {
+	public static flags = {
 		help: cf.help,
 	};
 
 	public static authenticated = true;
 
 	public async run() {
-		const { args: params } = this.parse<FlagsDef, ArgsDef>(DeviceIdentifyCmd);
+		const { args: params } = await this.parse(DeviceIdentifyCmd);
 
 		const balena = getBalenaSdk();
 

lib/commands/device/index.ts

@@ -15,13 +15,12 @@
  * limitations under the License.
  */
 
-import { flags } from '@oclif/command';
-import { IArg } from '@oclif/parser/lib/args';
+import { Flags, Args } from '@oclif/core';
 import Command from '../../command';
 import * as cf from '../../utils/common-flags';
 import { expandForAppName } from '../../utils/helpers';
 import { getBalenaSdk, getVisuals, stripIndent } from '../../utils/lazy';
-import { tryAsInteger } from '../../utils/validation';
+import { jsonInfo } from '../../utils/messages';
 
 import type { Application, Release } from 'balena-sdk';
 
@@ -42,72 +41,93 @@ interface ExtendedDevice extends DeviceWithDeviceType {
 	undervoltage_detected?: boolean;
 }
 
-interface FlagsDef {
-	help: void;
-}
-
-interface ArgsDef {
-	uuid: string;
-}
-
 export default class DeviceCmd extends Command {
 	public static description = stripIndent`
 		Show info about a single device.
 
 		Show information about a single device.
-		`;
-	public static examples = ['$ balena device 7cf02a6'];
 
-	public static args: Array<IArg<any>> = [
-		{
-			name: 'uuid',
-			description: 'the device uuid',
-			parse: (dev) => tryAsInteger(dev),
-			required: true,
-		},
+		${jsonInfo.split('\n').join('\n\t\t')}
+		`;
+	public static examples = [
+		'$ balena device 7cf02a6',
+		'$ balena device 7cf02a6 --view',
+		'$ balena device 7cf02a6 --json',
 	];
 
+	public static args = {
+		uuid: Args.string({
+			description: 'the device uuid',
+			required: true,
+		}),
+	};
+
 	public static usage = 'device <uuid>';
 
-	public static flags: flags.Input<FlagsDef> = {
+	public static flags = {
+		json: cf.json,
 		help: cf.help,
+		view: Flags.boolean({
+			default: false,
+			description: 'open device dashboard page',
+		}),
 	};
 
 	public static authenticated = true;
 	public static primary = true;
 
 	public async run() {
-		const { args: params } = this.parse<FlagsDef, ArgsDef>(DeviceCmd);
+		const { args: params, flags: options } = await this.parse(DeviceCmd);
 
 		const balena = getBalenaSdk();
 
-		const device = (await balena.models.device.get(params.uuid, {
-			$select: [
-				'device_name',
-				'id',
-				'overall_status',
-				'is_online',
-				'ip_address',
-				'mac_address',
-				'last_connectivity_event',
-				'uuid',
-				'supervisor_version',
-				'is_web_accessible',
-				'note',
-				'os_version',
-				'memory_usage',
-				'memory_total',
-				'public_address',
-				'storage_block_device',
-				'storage_usage',
-				'storage_total',
-				'cpu_usage',
-				'cpu_temp',
-				'cpu_id',
-				'is_undervolted',
-			],
-			...expandForAppName,
-		})) as ExtendedDevice;
+		const device = (await balena.models.device.get(
+			params.uuid,
+			options.json
+				? {
+						$expand: {
+							device_tag: {
+								$select: ['tag_key', 'value'],
+							},
+							...expandForAppName.$expand,
+						},
+				  }
+				: {
+						$select: [
+							'device_name',
+							'id',
+							'overall_status',
+							'is_online',
+							'ip_address',
+							'mac_address',
+							'last_connectivity_event',
+							'uuid',
+							'supervisor_version',
+							'is_web_accessible',
+							'note',
+							'os_version',
+							'memory_usage',
+							'memory_total',
+							'public_address',
+							'storage_block_device',
+							'storage_usage',
+							'storage_total',
+							'cpu_usage',
+							'cpu_temp',
+							'cpu_id',
+							'is_undervolted',
+						],
+						...expandForAppName,
+				  },
+		)) as ExtendedDevice;
+
+		if (options.view) {
+			const open = await import('open');
+			const dashboardUrl = balena.models.device.getDashboardUrl(device.uuid);
+			await open(dashboardUrl, { wait: false });
+			return;
+		}
+
 		device.status = device.overall_status;
 
 		device.dashboard_url = balena.models.device.getDashboardUrl(device.uuid);
@@ -163,6 +183,11 @@ export default class DeviceCmd extends Command {
 			);
 		}
 
+		if (options.json) {
+			console.log(JSON.stringify(device, null, 4));
+			return;
+		}
+
 		console.log(
 			getVisuals().table.vertical(device, [
 				`$${device.device_name}$`,

lib/commands/device/init.ts

@@ -15,7 +15,7 @@
  * limitations under the License.
  */
 
-import { flags } from '@oclif/command';
+import { Flags } from '@oclif/core';
 import Command from '../../command';
 import * as cf from '../../utils/common-flags';
 import { getBalenaSdk, stripIndent } from '../../utils/lazy';
@@ -31,6 +31,7 @@ interface FlagsDef {
 	config?: string;
 	help: void;
 	'provisioning-key-name'?: string;
+	'provisioning-key-expiry-date'?: string;
 }
 
 export default class DeviceInitCmd extends Command {
@@ -69,19 +70,20 @@ export default class DeviceInitCmd extends Command {
 	public static examples = [
 		'$ balena device init',
 		'$ balena device init -f myorg/myfleet',
+		'$ balena device init --fleet myFleet --os-version 2.101.7 --drive /dev/disk5 --config config.json --yes',
 		'$ balena device init --fleet myFleet --os-version 2.83.21+rev1.prod --drive /dev/disk5 --config config.json --yes',
 	];
 
 	public static usage = 'device init';
 
-	public static flags: flags.Input<FlagsDef> = {
+	public static flags = {
 		fleet: cf.fleet,
 		yes: cf.yes,
-		advanced: flags.boolean({
+		advanced: Flags.boolean({
 			char: 'v',
 			description: 'show advanced configuration options',
 		}),
-		'os-version': flags.string({
+		'os-version': Flags.string({
 			description: stripIndent`
 				exact version number, or a valid semver range,
 				or 'latest' (includes pre-releases),
@@ -91,19 +93,23 @@ export default class DeviceInitCmd extends Command {
 				`,
 		}),
 		drive: cf.drive,
-		config: flags.string({
+		config: Flags.string({
 			description: 'path to the config JSON file, see `balena os build-config`',
 		}),
-		'provisioning-key-name': flags.string({
+		'provisioning-key-name': Flags.string({
 			description: 'custom key name assigned to generated provisioning api key',
 		}),
+		'provisioning-key-expiry-date': Flags.string({
+			description:
+				'expiry date assigned to generated provisioning api key (format: YYYY-MM-DD)',
+		}),
 		help: cf.help,
 	};
 
 	public static authenticated = true;
 
 	public async run() {
-		const { flags: options } = this.parse<FlagsDef, {}>(DeviceInitCmd);
+		const { flags: options } = await this.parse(DeviceInitCmd);
 
 		// Imports
 		const { promisify } = await import('util');
@@ -118,20 +124,16 @@ export default class DeviceInitCmd extends Command {
 		const balena = getBalenaSdk();
 
 		// Get application and
-		const application = (await getApplication(
-			balena,
-			options.fleet ||
-				(
-					await (await import('../../utils/patterns')).selectApplication()
-				).id,
-			{
-				$expand: {
-					is_for__device_type: {
-						$select: 'slug',
+		const application = options.fleet
+			? await getApplication(balena, options.fleet, {
+					$select: ['id', 'slug'],
+					$expand: {
+						is_for__device_type: {
+							$select: 'slug',
+						},
 					},
-				},
-			},
-		)) as ApplicationWithDeviceType;
+			  })
+			: await (await import('../../utils/patterns')).selectApplication();
 
 		// Register new device
 		const deviceUuid = balena.models.device.generateUniqueKey();
@@ -185,6 +187,14 @@ export default class DeviceInitCmd extends Command {
 				options['provisioning-key-name'],
 			);
 		}
+
+		if (options['provisioning-key-expiry-date']) {
+			configureCommand.push(
+				'--provisioning-key-expiry-date',
+				options['provisioning-key-expiry-date'],
+			);
+		}
+
 		await runCommand(configureCommand);
 	}
 

lib/commands/device/local-mode.ts

@@ -15,23 +15,10 @@
  * limitations under the License.
  */
 
-import { flags } from '@oclif/command';
-import type { IArg } from '@oclif/parser/lib/args';
+import { Flags, Args } from '@oclif/core';
 import Command from '../../command';
 import * as cf from '../../utils/common-flags';
 import { getBalenaSdk, stripIndent } from '../../utils/lazy';
-import { tryAsInteger } from '../../utils/validation';
-
-interface FlagsDef {
-	enable: boolean;
-	disable: boolean;
-	status: boolean;
-	help?: void;
-}
-
-interface ArgsDef {
-	uuid: string | number;
-}
 
 export default class DeviceLocalModeCmd extends Command {
 	public static description = stripIndent`
@@ -48,27 +35,25 @@ export default class DeviceLocalModeCmd extends Command {
 		'$ balena device local-mode 23c73a1 --status',
 	];
 
-	public static args: Array<IArg<any>> = [
-		{
-			name: 'uuid',
+	public static args = {
+		uuid: Args.string({
 			description: 'the uuid of the device to manage',
-			parse: (dev) => tryAsInteger(dev),
 			required: true,
-		},
-	];
+		}),
+	};
 
 	public static usage = 'device local-mode <uuid>';
 
-	public static flags: flags.Input<FlagsDef> = {
-		enable: flags.boolean({
+	public static flags = {
+		enable: Flags.boolean({
 			description: 'enable local mode',
 			exclusive: ['disable', 'status'],
 		}),
-		disable: flags.boolean({
+		disable: Flags.boolean({
 			description: 'disable local mode',
 			exclusive: ['enable', 'status'],
 		}),
-		status: flags.boolean({
+		status: Flags.boolean({
 			description: 'output boolean indicating local mode status',
 			exclusive: ['enable', 'disable'],
 		}),
@@ -78,9 +63,8 @@ export default class DeviceLocalModeCmd extends Command {
 	public static authenticated = true;
 
 	public async run() {
-		const { args: params, flags: options } = this.parse<FlagsDef, ArgsDef>(
-			DeviceLocalModeCmd,
-		);
+		const { args: params, flags: options } =
+			await this.parse(DeviceLocalModeCmd);
 
 		const balena = getBalenaSdk();
 

lib/commands/device/move.ts

@@ -15,12 +15,11 @@
  * limitations under the License.
  */
 
-import type { flags } from '@oclif/command';
-import type { IArg } from '@oclif/parser/lib/args';
+import { Args } from '@oclif/core';
 import type {
 	BalenaSDK,
 	Device,
-	DeviceType,
+	PineOptions,
 	PineTypedResult,
 } from 'balena-sdk';
 import Command from '../../command';
@@ -29,22 +28,6 @@ import { ExpectedError } from '../../errors';
 import { getBalenaSdk, stripIndent } from '../../utils/lazy';
 import { applicationIdInfo } from '../../utils/messages';
 
-type ExtendedDevice = PineTypedResult<
-	Device,
-	typeof import('../../utils/helpers').expandForAppNameAndCpuArch
-> & {
-	application_name?: string;
-};
-
-interface FlagsDef {
-	fleet?: string;
-	help: void;
-}
-
-interface ArgsDef {
-	uuid: string;
-}
-
 export default class DeviceMoveCmd extends Command {
 	public static description = stripIndent`
 		Move one or more devices to another fleet.
@@ -63,68 +46,70 @@ export default class DeviceMoveCmd extends Command {
 		'$ balena device move 7cf02a6 -f myorg/mynewfleet',
 	];
 
-	public static args: Array<IArg<any>> = [
-		{
-			name: 'uuid',
+	public static args = {
+		uuid: Args.string({
 			description:
 				'comma-separated list (no blank spaces) of device UUIDs to be moved',
 			required: true,
-		},
-	];
+		}),
+	};
 
 	public static usage = 'device move <uuid(s)>';
 
-	public static flags: flags.Input<FlagsDef> = {
+	public static flags = {
 		fleet: cf.fleet,
 		help: cf.help,
 	};
 
 	public static authenticated = true;
 
-	public async run() {
-		const { args: params, flags: options } = this.parse<FlagsDef, ArgsDef>(
-			DeviceMoveCmd,
+	private async getDevices(balena: BalenaSDK, deviceUuids: string[]) {
+		const deviceOptions = {
+			$select: 'belongs_to__application',
+			$expand: {
+				is_of__device_type: {
+					$select: 'is_of__cpu_architecture',
+					$expand: {
+						is_of__cpu_architecture: {
+							$select: 'slug',
+						},
+					},
+				},
+			},
+		} satisfies PineOptions<Device>;
+
+		// TODO: Refacor once `device.get()` accepts an array of uuids`
+		const devices = await Promise.all(
+			deviceUuids.map(
+				(uuid) =>
+					balena.models.device.get(uuid, deviceOptions) as Promise<
+						PineTypedResult<Device, typeof deviceOptions>
+					>,
+			),
 		);
+		return devices;
+	}
+
+	public async run() {
+		const { args: params, flags: options } = await this.parse(DeviceMoveCmd);
 
 		const balena = getBalenaSdk();
 
-		const { tryAsInteger } = await import('../../utils/validation');
-		const { expandForAppNameAndCpuArch } = await import('../../utils/helpers');
+		// Split uuids string into array of uuids
+		const deviceUuids = params.uuid.split(',');
 
-		// Parse ids string into array of correct types
-		const deviceIds: Array<string | number> = params.uuid
-			.split(',')
-			.map((id) => tryAsInteger(id));
+		const devices = await this.getDevices(balena, deviceUuids);
 
-		// Get devices
-		const devices = await Promise.all(
-			deviceIds.map(
-				(uuid) =>
-					balena.models.device.get(
-						uuid,
-						expandForAppNameAndCpuArch,
-					) as Promise<ExtendedDevice>,
-			),
-		);
-
-		// Map application name for each device
-		for (const device of devices) {
-			const belongsToApplication = device.belongs_to__application;
-			device.application_name = belongsToApplication?.[0]
-				? belongsToApplication[0].app_name
-				: 'N/a';
-		}
-
-		// Disambiguate application (if is a number, it could either be an ID or a numerical name)
+		// Disambiguate application
 		const { getApplication } = await import('../../utils/sdk');
 
 		// Get destination application
 		const application = options.fleet
-			? await getApplication(balena, options.fleet)
+			? await getApplication(balena, options.fleet, { $select: ['id', 'slug'] })
 			: await this.interactivelySelectApplication(balena, devices);
 
 		// Move each device
-		for (const uuid of deviceIds) {
+		for (const uuid of deviceUuids) {
 			try {
 				await balena.models.device.move(uuid, application.id);
 				console.info(`Device ${uuid} was moved to fleet ${application.slug}`);
@@ -137,9 +122,8 @@ export default class DeviceMoveCmd extends Command {
 
 	async interactivelySelectApplication(
 		balena: BalenaSDK,
-		devices: ExtendedDevice[],
+		devices: Awaited<ReturnType<typeof this.getDevices>>,
 	) {
-		const { getExpandedProp } = await import('../../utils/pine');
 		// deduplicate the slugs
 		const deviceCpuArchs = Array.from(
 			new Set(
@@ -149,46 +133,44 @@ export default class DeviceMoveCmd extends Command {
 			),
 		);
 
-		const deviceTypeOptions = {
-			$select: 'slug',
-			$expand: {
-				is_of__cpu_architecture: {
-					$select: 'slug',
-				},
+		const allCpuArches = await balena.pine.get({
+			resource: 'cpu_architecture',
+			options: {
+				$select: ['id', 'slug'],
 			},
-		} as const;
-		const deviceTypes = (await balena.models.deviceType.getAllSupported(
-			deviceTypeOptions,
-		)) as Array<PineTypedResult<DeviceType, typeof deviceTypeOptions>>;
+		});
 
-		const compatibleDeviceTypeSlugs = new Set(
-			deviceTypes
-				.filter((deviceType) => {
-					const deviceTypeArch = getExpandedProp(
-						deviceType.is_of__cpu_architecture,
-						'slug',
-					)!;
-					return deviceCpuArchs.every((deviceCpuArch) =>
-						balena.models.os.isArchitectureCompatibleWith(
-							deviceCpuArch,
-							deviceTypeArch,
-						),
-					);
-				})
-				.map((deviceType) => deviceType.slug),
-		);
+		const compatibleCpuArchIds = allCpuArches
+			.filter((cpuArch) => {
+				return deviceCpuArchs.every((deviceCpuArch) =>
+					balena.models.os.isArchitectureCompatibleWith(
+						deviceCpuArch,
+						cpuArch.slug,
+					),
+				);
+			})
+			.map((deviceType) => deviceType.id);
 
 		const patterns = await import('../../utils/patterns');
 		try {
 			const application = await patterns.selectApplication(
-				(app) =>
-					compatibleDeviceTypeSlugs.has(app.is_for__device_type[0].slug) &&
-					devices.some((device) => device.application_name !== app.app_name),
+				{
+					is_for__device_type: {
+						$any: {
+							$alias: 'dt',
+							$expr: {
+								dt: {
+									is_of__cpu_architecture: { $in: compatibleCpuArchIds },
+								},
+							},
+						},
+					},
+				},
 				true,
 			);
 			return application;
 		} catch (err) {
-			if (!compatibleDeviceTypeSlugs.size) {
+			if (!compatibleCpuArchIds.length) {
 				throw new ExpectedError(
 					`${err.message}\nDo all devices have a compatible architecture?`,
 				);

lib/commands/device/os-update.ts

@@ -15,25 +15,13 @@
  * limitations under the License.
  */
 
-import { flags } from '@oclif/command';
-import type { IArg } from '@oclif/parser/lib/args';
+import { Flags, Args } from '@oclif/core';
 import Command from '../../command';
 import * as cf from '../../utils/common-flags';
 import { getBalenaSdk, stripIndent, getCliForm } from '../../utils/lazy';
-import { tryAsInteger } from '../../utils/validation';
 import type { Device } from 'balena-sdk';
 import { ExpectedError } from '../../errors';
 
-interface FlagsDef {
-	version?: string;
-	yes: boolean;
-	help: void;
-}
-
-interface ArgsDef {
-	uuid: string;
-}
-
 export default class DeviceOsUpdateCmd extends Command {
 	public static description = stripIndent`
 		Start a Host OS update for a device.
@@ -47,23 +35,29 @@ export default class DeviceOsUpdateCmd extends Command {
 		`;
 	public static examples = [
 		'$ balena device os-update 23c73a1',
+		'$ balena device os-update 23c73a1 --version 2.101.7',
 		'$ balena device os-update 23c73a1 --version 2.31.0+rev1.prod',
+		'$ balena device os-update 23c73a1 --include-draft',
 	];
 
-	public static args: Array<IArg<any>> = [
-		{
-			name: 'uuid',
+	public static args = {
+		uuid: Args.string({
 			description: 'the uuid of the device to update',
-			parse: (dev) => tryAsInteger(dev),
 			required: true,
-		},
-	];
+		}),
+	};
 
 	public static usage = 'device os-update <uuid>';
 
-	public static flags: flags.Input<FlagsDef> = {
-		version: flags.string({
+	public static flags = {
+		version: Flags.string({
 			description: 'a balenaOS version',
+			exclusive: ['include-draft'],
+		}),
+		'include-draft': Flags.boolean({
+			description: 'include pre-release balenaOS versions',
+			default: false,
+			exclusive: ['version'],
 		}),
 		yes: cf.yes,
 		help: cf.help,
@@ -72,9 +66,8 @@ export default class DeviceOsUpdateCmd extends Command {
 	public static authenticated = true;
 
 	public async run() {
-		const { args: params, flags: options } = this.parse<FlagsDef, ArgsDef>(
-			DeviceOsUpdateCmd,
-		);
+		const { args: params, flags: options } =
+			await this.parse(DeviceOsUpdateCmd);
 
 		const sdk = getBalenaSdk();
 
@@ -100,10 +93,25 @@ export default class DeviceOsUpdateCmd extends Command {
 			);
 		}
 
+		let includeDraft = options['include-draft'];
+		if (!includeDraft && options.version != null) {
+			const bSemver = await import('balena-semver');
+			const parsedVersion = bSemver.parse(options.version);
+			// When the user provides a draft version, we need to pass `includeDraft`
+			// to the os.getSupportedOsUpdateVersions() since w/o it the results
+			// will for sure not include the user provided version and the command
+			// would return a "not in the Host OS update targets" error.
+			includeDraft =
+				parsedVersion != null && parsedVersion.prerelease.length > 0;
+		}
+
 		// Get supported OS update versions
 		const hupVersionInfo = await sdk.models.os.getSupportedOsUpdateVersions(
 			is_of__device_type[0].slug,
 			currentOsVersion,
+			{
+				includeDraft,
+			},
 		);
 		if (hupVersionInfo.versions.length === 0) {
 			throw new ExpectedError(
@@ -114,6 +122,8 @@ export default class DeviceOsUpdateCmd extends Command {
 		// Get target OS version
 		let targetOsVersion = options.version;
 		if (targetOsVersion != null) {
+			const { normalizeOsVersion } = await import('../../utils/normalization');
+			targetOsVersion = normalizeOsVersion(targetOsVersion);
 			if (!hupVersionInfo.versions.includes(targetOsVersion)) {
 				throw new ExpectedError(
 					`The provided version ${targetOsVersion} is not in the Host OS update targets for this device`,

lib/commands/device/pin.ts

@@ -0,0 +1,91 @@
+/**
+ * @license
+ * Copyright 2016-2020 Balena Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { Args } from '@oclif/core';
+import Command from '../../command';
+import * as cf from '../../utils/common-flags';
+import { getBalenaSdk, stripIndent } from '../../utils/lazy';
+import { getExpandedProp } from '../../utils/pine';
+
+export default class DevicePinCmd extends Command {
+	public static description = stripIndent`
+		Pin a device to a release.
+
+		Pin a device to a release.
+
+		Note, if the commit is omitted, the currently pinned release will be printed, with instructions for how to see a list of releases
+		`;
+	public static examples = [
+		'$ balena device pin 7cf02a6',
+		'$ balena device pin 7cf02a6 91165e5',
+	];
+
+	public static args = {
+		uuid: Args.string({
+			description: 'the uuid of the device to pin to a release',
+			required: true,
+		}),
+		releaseToPinTo: Args.string({
+			description: 'the commit of the release for the device to get pinned to',
+		}),
+	};
+
+	public static usage = 'device pin <uuid> [releaseToPinTo]';
+
+	public static flags = {
+		help: cf.help,
+	};
+
+	public static authenticated = true;
+
+	public async run() {
+		const { args: params } = await this.parse(DevicePinCmd);
+
+		const balena = getBalenaSdk();
+
+		const device = await balena.models.device.get(params.uuid, {
+			$expand: {
+				should_be_running__release: {
+					$select: 'commit',
+				},
+				belongs_to__application: {
+					$select: 'slug',
+				},
+			},
+		});
+
+		const pinnedRelease = getExpandedProp(
+			device.should_be_running__release,
+			'commit',
+		);
+		const appSlug = getExpandedProp(device.belongs_to__application, 'slug');
+
+		const releaseToPinTo = params.releaseToPinTo;
+
+		if (!releaseToPinTo) {
+			console.log(
+				`${
+					pinnedRelease
+						? `This device is currently pinned to ${pinnedRelease}.`
+						: 'This device is not currently pinned to any release.'
+				} \n\nTo see a list of all releases this device can be pinned to, run \`balena releases ${appSlug}\`.`,
+			);
+		} else {
+			await balena.models.device.pinToRelease(params.uuid, releaseToPinTo);
+		}
+	}
+}

lib/commands/device/public-url.ts

@@ -15,26 +15,11 @@
  * limitations under the License.
  */
 
-import { flags } from '@oclif/command';
-import type { IArg } from '@oclif/parser/lib/args';
+import { Flags, Args } from '@oclif/core';
 import Command from '../../command';
 import { ExpectedError } from '../../errors';
 import * as cf from '../../utils/common-flags';
 import { getBalenaSdk, stripIndent } from '../../utils/lazy';
-import { tryAsInteger } from '../../utils/validation';
-
-interface FlagsDef {
-	enable: boolean;
-	disable: boolean;
-	status: boolean;
-	help?: void;
-}
-
-interface ArgsDef {
-	uuid: string;
-	// Optional hidden arg to support old command format
-	legacyUuid?: string;
-}
 
 export default class DevicePublicUrlCmd extends Command {
 	public static description = stripIndent`
@@ -43,9 +28,6 @@ export default class DevicePublicUrlCmd extends Command {
 		This command will output the current public URL for the
 		specified device.  It can also enable or disable the URL,
 		or output the enabled status, using the respective options.
-
-		The old command style 'balena device public-url enable <uuid>'
-		is deprecated, but still supported.
 	`;
 
 	public static examples = [
@@ -55,33 +37,25 @@ export default class DevicePublicUrlCmd extends Command {
 		'$ balena device public-url 23c73a1 --status',
 	];
 
-	public static args: Array<IArg<any>> = [
-		{
-			name: 'uuid',
+	public static args = {
+		uuid: Args.string({
 			description: 'the uuid of the device to manage',
-			parse: (dev) => tryAsInteger(dev),
 			required: true,
-		},
-		{
-			// Optional hidden arg to support old command format
-			name: 'legacyUuid',
-			parse: (dev) => tryAsInteger(dev),
-			hidden: true,
-		},
-	];
+		}),
+	};
 
 	public static usage = 'device public-url <uuid>';
 
-	public static flags: flags.Input<FlagsDef> = {
-		enable: flags.boolean({
+	public static flags = {
+		enable: Flags.boolean({
 			description: 'enable the public URL',
 			exclusive: ['disable', 'status'],
 		}),
-		disable: flags.boolean({
+		disable: Flags.boolean({
 			description: 'disable the public URL',
 			exclusive: ['enable', 'status'],
 		}),
-		status: flags.boolean({
+		status: Flags.boolean({
 			description: 'determine if public URL is enabled',
 			exclusive: ['enable', 'disable'],
 		}),
@@ -91,28 +65,8 @@ export default class DevicePublicUrlCmd extends Command {
 	public static authenticated = true;
 
 	public async run() {
-		const { args: params, flags: options } = this.parse<FlagsDef, ArgsDef>(
-			DevicePublicUrlCmd,
-		);
-
-		// Legacy command format support.
-		// Previously this command used the following format
-		// (changed due to oclif technicalities):
-		//   `balena device public-url enable|disable|status <uuid>`
-		if (params.legacyUuid) {
-			const action = params.uuid;
-			if (!['enable', 'disable', 'status'].includes(action)) {
-				throw new ExpectedError(
-					`Unexpected arguments: ${params.uuid} ${params.legacyUuid}`,
-				);
-			}
-
-			options.enable = action === 'enable';
-			options.disable = action === 'disable';
-			options.status = action === 'status';
-			params.uuid = params.legacyUuid;
-			delete params.legacyUuid;
-		}
+		const { args: params, flags: options } =
+			await this.parse(DevicePublicUrlCmd);
 
 		const balena = getBalenaSdk();
 

lib/commands/device/purge.ts

@@ -15,20 +15,11 @@
  * limitations under the License.
  */
 
-import { flags } from '@oclif/command';
-import type { IArg } from '@oclif/parser/lib/args';
+import { Args } from '@oclif/core';
 import Command from '../../command';
 import * as cf from '../../utils/common-flags';
 import { getBalenaSdk, getCliUx, stripIndent } from '../../utils/lazy';
 
-interface FlagsDef {
-	help: void;
-}
-
-interface ArgsDef {
-	uuid: string;
-}
-
 export default class DevicePurgeCmd extends Command {
 	public static description = stripIndent`
 		Purge data from a device.
@@ -46,34 +37,30 @@ export default class DevicePurgeCmd extends Command {
 
 	public static usage = 'device purge <uuid>';
 
-	public static args: Array<IArg<any>> = [
-		{
-			name: 'uuid',
+	public static args = {
+		uuid: Args.string({
 			description: 'comma-separated list (no blank spaces) of device UUIDs',
 			required: true,
-		},
-	];
+		}),
+	};
 
-	public static flags: flags.Input<FlagsDef> = {
+	public static flags = {
 		help: cf.help,
 	};
 
 	public static authenticated = true;
 
 	public async run() {
-		const { args: params } = this.parse<FlagsDef, ArgsDef>(DevicePurgeCmd);
+		const { args: params } = await this.parse(DevicePurgeCmd);
 
-		const { tryAsInteger } = await import('../../utils/validation');
 		const balena = getBalenaSdk();
 		const ux = getCliUx();
 
-		const deviceIds = params.uuid.split(',').map((id) => {
-			return tryAsInteger(id);
-		});
+		const deviceUuids = params.uuid.split(',');
 
-		for (const deviceId of deviceIds) {
-			ux.action.start(`Purging data from device ${deviceId}`);
-			await balena.models.device.purge(deviceId);
+		for (const uuid of deviceUuids) {
+			ux.action.start(`Purging data from device ${uuid}`);
+			await balena.models.device.purge(uuid);
 			ux.action.stop();
 		}
 	}

lib/commands/device/reboot.ts

@@ -15,21 +15,10 @@
  * limitations under the License.
  */
 
-import { flags } from '@oclif/command';
-import type { IArg } from '@oclif/parser/lib/args';
+import { Args } from '@oclif/core';
 import Command from '../../command';
 import * as cf from '../../utils/common-flags';
 import { getBalenaSdk, stripIndent } from '../../utils/lazy';
-import { tryAsInteger } from '../../utils/validation';
-
-interface FlagsDef {
-	force: boolean;
-	help: void;
-}
-
-interface ArgsDef {
-	uuid: string;
-}
 
 export default class DeviceRebootCmd extends Command {
 	public static description = stripIndent`
@@ -39,18 +28,16 @@ export default class DeviceRebootCmd extends Command {
 		`;
 	public static examples = ['$ balena device reboot 23c73a1'];
 
-	public static args: Array<IArg<any>> = [
-		{
-			name: 'uuid',
+	public static args = {
+		uuid: Args.string({
 			description: 'the uuid of the device to reboot',
-			parse: (dev) => tryAsInteger(dev),
 			required: true,
-		},
-	];
+		}),
+	};
 
 	public static usage = 'device reboot <uuid>';
 
-	public static flags: flags.Input<FlagsDef> = {
+	public static flags = {
 		force: cf.force,
 		help: cf.help,
 	};
@@ -58,9 +45,7 @@ export default class DeviceRebootCmd extends Command {
 	public static authenticated = true;
 
 	public async run() {
-		const { args: params, flags: options } = this.parse<FlagsDef, ArgsDef>(
-			DeviceRebootCmd,
-		);
+		const { args: params, flags: options } = await this.parse(DeviceRebootCmd);
 
 		const balena = getBalenaSdk();
 

lib/commands/device/register.ts

@@ -15,23 +15,13 @@
  * limitations under the License.
  */
 
-import { flags } from '@oclif/command';
-import type { IArg } from '@oclif/parser/lib/args';
+import { Flags } from '@oclif/core';
 import Command from '../../command';
 import * as cf from '../../utils/common-flags';
 import * as ca from '../../utils/common-args';
 import { getBalenaSdk, stripIndent } from '../../utils/lazy';
 import { applicationIdInfo } from '../../utils/messages';
 
-interface FlagsDef {
-	uuid?: string;
-	help: void;
-}
-
-interface ArgsDef {
-	fleet: string;
-}
-
 export default class DeviceRegisterCmd extends Command {
 	public static description = stripIndent`
 		Register a new device.
@@ -47,37 +37,49 @@ export default class DeviceRegisterCmd extends Command {
 		'$ balena device register MyFleet',
 		'$ balena device register MyFleet --uuid <uuid>',
 		'$ balena device register myorg/myfleet --uuid <uuid>',
+		'$ balena device register myorg/myfleet --uuid <uuid> --deviceType <deviceTypeSlug>',
 	];
 
-	public static args: Array<IArg<any>> = [ca.fleetRequired];
+	public static args = {
+		fleet: ca.fleetRequired,
+	};
 
 	public static usage = 'device register <fleet>';
 
-	public static flags: flags.Input<FlagsDef> = {
-		uuid: flags.string({
+	public static flags = {
+		uuid: Flags.string({
 			description: 'custom uuid',
 			char: 'u',
 		}),
+		deviceType: Flags.string({
+			description:
+				"device type slug (run 'balena devices supported' for possible values)",
+		}),
 		help: cf.help,
 	};
 
 	public static authenticated = true;
 
 	public async run() {
-		const { args: params, flags: options } = this.parse<FlagsDef, ArgsDef>(
-			DeviceRegisterCmd,
-		);
+		const { args: params, flags: options } =
+			await this.parse(DeviceRegisterCmd);
 
 		const { getApplication } = await import('../../utils/sdk');
 
 		const balena = getBalenaSdk();
 
-		const application = await getApplication(balena, params.fleet);
+		const application = await getApplication(balena, params.fleet, {
+			$select: ['id', 'slug'],
+		});
 		const uuid = options.uuid ?? balena.models.device.generateUniqueKey();
 
 		console.info(`Registering to ${application.slug}: ${uuid}`);
 
-		const result = await balena.models.device.register(application.id, uuid);
+		const result = await balena.models.device.register(
+			application.id,
+			uuid,
+			options.deviceType,
+		);
 
 		return result && result.uuid;
 	}

lib/commands/device/rename.ts

@@ -15,21 +15,10 @@
  * limitations under the License.
  */
 
-import { flags } from '@oclif/command';
-import type { IArg } from '@oclif/parser/lib/args';
+import { Args } from '@oclif/core';
 import Command from '../../command';
 import * as cf from '../../utils/common-flags';
 import { getBalenaSdk, stripIndent, getCliForm } from '../../utils/lazy';
-import { tryAsInteger } from '../../utils/validation';
-
-interface FlagsDef {
-	help: void;
-}
-
-interface ArgsDef {
-	uuid: string;
-	newName?: string;
-}
 
 export default class DeviceRenameCmd extends Command {
 	public static description = stripIndent`
@@ -44,29 +33,26 @@ export default class DeviceRenameCmd extends Command {
 		'$ balena device rename 7cf02a6 MyPi',
 	];
 
-	public static args: Array<IArg<any>> = [
-		{
-			name: 'uuid',
+	public static args = {
+		uuid: Args.string({
 			description: 'the uuid of the device to rename',
-			parse: (dev) => tryAsInteger(dev),
 			required: true,
-		},
-		{
-			name: 'newName',
+		}),
+		newName: Args.string({
 			description: 'the new name for the device',
-		},
-	];
+		}),
+	};
 
 	public static usage = 'device rename <uuid> [newName]';
 
-	public static flags: flags.Input<FlagsDef> = {
+	public static flags = {
 		help: cf.help,
 	};
 
 	public static authenticated = true;
 
 	public async run() {
-		const { args: params } = this.parse<FlagsDef, ArgsDef>(DeviceRenameCmd);
+		const { args: params } = await this.parse(DeviceRenameCmd);
 
 		const balena = getBalenaSdk();
 

lib/commands/device/restart.ts

@@ -15,8 +15,7 @@
  * limitations under the License.
  */
 
-import { flags } from '@oclif/command';
-import type { IArg } from '@oclif/parser/lib/args';
+import { Flags, Args } from '@oclif/core';
 import Command from '../../command';
 import * as cf from '../../utils/common-flags';
 import { getBalenaSdk, getCliUx, stripIndent } from '../../utils/lazy';
@@ -26,15 +25,6 @@ import type {
 	CurrentServiceWithCommit,
 } from 'balena-sdk';
 
-interface FlagsDef {
-	help: void;
-	service?: string;
-}
-
-interface ArgsDef {
-	uuid: string;
-}
-
 export default class DeviceRestartCmd extends Command {
 	public static description = stripIndent`
 		Restart containers on a device.
@@ -55,19 +45,18 @@ export default class DeviceRestartCmd extends Command {
 		'$ balena device restart 23c73a1 -s myService1,myService2',
 	];
 
-	public static args: Array<IArg<any>> = [
-		{
-			name: 'uuid',
+	public static args = {
+		uuid: Args.string({
 			description:
 				'comma-separated list (no blank spaces) of device UUIDs to restart',
 			required: true,
-		},
-	];
+		}),
+	};
 
 	public static usage = 'device restart <uuid>';
 
-	public static flags: flags.Input<FlagsDef> = {
-		service: flags.string({
+	public static flags = {
+		service: Flags.string({
 			description:
 				'comma-separated list (no blank spaces) of service names to restart',
 			char: 's',
@@ -78,28 +67,23 @@ export default class DeviceRestartCmd extends Command {
 	public static authenticated = true;
 
 	public async run() {
-		const { args: params, flags: options } = this.parse<FlagsDef, ArgsDef>(
-			DeviceRestartCmd,
-		);
+		const { args: params, flags: options } = await this.parse(DeviceRestartCmd);
 
-		const { tryAsInteger } = await import('../../utils/validation');
 		const balena = getBalenaSdk();
 		const ux = getCliUx();
 
-		const deviceIds = params.uuid.split(',').map((id) => {
-			return tryAsInteger(id);
-		});
+		const deviceUuids = params.uuid.split(',');
 		const serviceNames = options.service?.split(',');
 
-		// Iterate sequentially through deviceIds.
+		// Iterate sequentially through deviceUuids.
 		// We may later want to add a batching feature,
 		// so that n devices are processed in parallel
-		for (const deviceId of deviceIds) {
-			ux.action.start(`Restarting services on device ${deviceId}`);
+		for (const uuid of deviceUuids) {
+			ux.action.start(`Restarting services on device ${uuid}`);
 			if (serviceNames) {
-				await this.restartServices(balena, deviceId, serviceNames);
+				await this.restartServices(balena, uuid, serviceNames);
 			} else {
-				await this.restartAllServices(balena, deviceId);
+				await this.restartAllServices(balena, uuid);
 			}
 			ux.action.stop();
 		}
@@ -107,7 +91,7 @@ export default class DeviceRestartCmd extends Command {
 
 	async restartServices(
 		balena: BalenaSDK,
-		deviceId: number | string,
+		deviceUuid: string,
 		serviceNames: string[],
 	) {
 		const { ExpectedError, instanceOf } = await import('../../errors');
@@ -116,7 +100,7 @@ export default class DeviceRestartCmd extends Command {
 		// Get device
 		let device: DeviceWithServiceDetails<CurrentServiceWithCommit>;
 		try {
-			device = await balena.models.device.getWithServiceDetails(deviceId, {
+			device = await balena.models.device.getWithServiceDetails(deviceUuid, {
 				$expand: {
 					is_running__release: { $select: 'commit' },
 				},
@@ -124,7 +108,7 @@ export default class DeviceRestartCmd extends Command {
 		} catch (e) {
 			const { BalenaDeviceNotFound } = await import('balena-errors');
 			if (instanceOf(e, BalenaDeviceNotFound)) {
-				throw new ExpectedError(`Device ${deviceId} not found.`);
+				throw new ExpectedError(`Device ${deviceUuid} not found.`);
 			} else {
 				throw e;
 			}
@@ -136,7 +120,7 @@ export default class DeviceRestartCmd extends Command {
 		serviceNames.forEach((service) => {
 			if (!device.current_services[service]) {
 				throw new ExpectedError(
-					`Service ${service} not found on device ${deviceId}.`,
+					`Service ${service} not found on device ${deviceUuid}.`,
 				);
 			}
 		});
@@ -155,7 +139,7 @@ export default class DeviceRestartCmd extends Command {
 			if (serviceContainer) {
 				restartPromises.push(
 					balena.models.device.restartService(
-						deviceId,
+						deviceUuid,
 						serviceContainer.image_id,
 					),
 				);
@@ -166,32 +150,32 @@ export default class DeviceRestartCmd extends Command {
 			await Promise.all(restartPromises);
 		} catch (e) {
 			if (e.message.toLowerCase().includes('no online device')) {
-				throw new ExpectedError(`Device ${deviceId} is not online.`);
+				throw new ExpectedError(`Device ${deviceUuid} is not online.`);
 			} else {
 				throw e;
 			}
 		}
 	}
 
-	async restartAllServices(balena: BalenaSDK, deviceId: number | string) {
+	async restartAllServices(balena: BalenaSDK, deviceUuid: string) {
 		// Note: device.restartApplication throws `BalenaDeviceNotFound: Device not found` if device not online.
 		// Need to use device.get first to distinguish between non-existant and offline devices.
 		// Remove this workaround when SDK issue resolved: https://github.com/balena-io/balena-sdk/issues/649
 		const { instanceOf, ExpectedError } = await import('../../errors');
 		try {
-			const device = await balena.models.device.get(deviceId);
+			const device = await balena.models.device.get(deviceUuid);
 			if (!device.is_online) {
-				throw new ExpectedError(`Device ${deviceId} is not online.`);
+				throw new ExpectedError(`Device ${deviceUuid} is not online.`);
 			}
 		} catch (e) {
 			const { BalenaDeviceNotFound } = await import('balena-errors');
 			if (instanceOf(e, BalenaDeviceNotFound)) {
-				throw new ExpectedError(`Device ${deviceId} not found.`);
+				throw new ExpectedError(`Device ${deviceUuid} not found.`);
 			} else {
 				throw e;
 			}
 		}
 
-		await balena.models.device.restartApplication(deviceId);
+		await balena.models.device.restartApplication(deviceUuid);
 	}
 }

lib/commands/device/rm.ts

@@ -15,21 +15,10 @@
  * limitations under the License.
  */
 
-import { flags } from '@oclif/command';
-import type { IArg } from '@oclif/parser/lib/args';
+import { Args } from '@oclif/core';
 import Command from '../../command';
 import * as cf from '../../utils/common-flags';
 import { getBalenaSdk, stripIndent } from '../../utils/lazy';
-import { tryAsInteger } from '../../utils/validation';
-
-interface FlagsDef {
-	yes: boolean;
-	help: void;
-}
-
-interface ArgsDef {
-	uuid: string;
-}
 
 export default class DeviceRmCmd extends Command {
 	public static description = stripIndent`
@@ -46,18 +35,17 @@ export default class DeviceRmCmd extends Command {
 		'$ balena device rm 7cf02a6 --yes',
 	];
 
-	public static args: Array<IArg<any>> = [
-		{
-			name: 'uuid',
+	public static args = {
+		uuid: Args.string({
 			description:
 				'comma-separated list (no blank spaces) of device UUIDs to be removed',
 			required: true,
-		},
-	];
+		}),
+	};
 
 	public static usage = 'device rm <uuid(s)>';
 
-	public static flags: flags.Input<FlagsDef> = {
+	public static flags = {
 		yes: cf.yes,
 		help: cf.help,
 	};
@@ -65,9 +53,7 @@ export default class DeviceRmCmd extends Command {
 	public static authenticated = true;
 
 	public async run() {
-		const { args: params, flags: options } = this.parse<FlagsDef, ArgsDef>(
-			DeviceRmCmd,
-		);
+		const { args: params, flags: options } = await this.parse(DeviceRmCmd);
 
 		const balena = getBalenaSdk();
 		const patterns = await import('../../utils/patterns');
@@ -84,7 +70,7 @@ export default class DeviceRmCmd extends Command {
 		// Remove
 		for (const uuid of uuids) {
 			try {
-				await balena.models.device.remove(tryAsInteger(uuid));
+				await balena.models.device.remove(uuid);
 			} catch (err) {
 				console.info(`${err.message}, uuid: ${uuid}`);
 				process.exitCode = 1;

lib/commands/device/shutdown.ts

@@ -15,23 +15,12 @@
  * limitations under the License.
  */
 
-import { flags } from '@oclif/command';
-import type { IArg } from '@oclif/parser/lib/args';
+import { Args } from '@oclif/core';
 import Command from '../../command';
 import * as cf from '../../utils/common-flags';
 import { getBalenaSdk, stripIndent } from '../../utils/lazy';
-import { tryAsInteger } from '../../utils/validation';
 import { ExpectedError } from '../../errors';
 
-interface FlagsDef {
-	force: boolean;
-	help: void;
-}
-
-interface ArgsDef {
-	uuid: string;
-}
-
 export default class DeviceShutdownCmd extends Command {
 	public static description = stripIndent`
 		Shutdown a device.
@@ -40,18 +29,16 @@ export default class DeviceShutdownCmd extends Command {
 		`;
 	public static examples = ['$ balena device shutdown 23c73a1'];
 
-	public static args: Array<IArg<any>> = [
-		{
-			name: 'uuid',
+	public static args = {
+		uuid: Args.string({
 			description: 'the uuid of the device to shutdown',
-			parse: (dev) => tryAsInteger(dev),
 			required: true,
-		},
-	];
+		}),
+	};
 
 	public static usage = 'device shutdown <uuid>';
 
-	public static flags: flags.Input<FlagsDef> = {
+	public static flags = {
 		force: cf.force,
 		help: cf.help,
 	};
@@ -59,9 +46,8 @@ export default class DeviceShutdownCmd extends Command {
 	public static authenticated = true;
 
 	public async run() {
-		const { args: params, flags: options } = this.parse<FlagsDef, ArgsDef>(
-			DeviceShutdownCmd,
-		);
+		const { args: params, flags: options } =
+			await this.parse(DeviceShutdownCmd);
 
 		const balena = getBalenaSdk();
 

lib/commands/device/start-service.ts

@@ -0,0 +1,139 @@
+/**
+ * @license
+ * Copyright 2016-2020 Balena Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { Args } from '@oclif/core';
+import Command from '../../command';
+import * as cf from '../../utils/common-flags';
+import { getBalenaSdk, getCliUx, stripIndent } from '../../utils/lazy';
+import type { BalenaSDK } from 'balena-sdk';
+
+export default class DeviceStartServiceCmd extends Command {
+	public static description = stripIndent`
+		Start containers on a device.
+
+		Start containers on a device.
+
+		Multiple devices and services may be specified with a comma-separated list
+		of values (no spaces).
+		`;
+	public static examples = [
+		'$ balena device start-service 23c73a1 myService',
+		'$ balena device start-service 23c73a1 myService1,myService2',
+	];
+
+	public static args = {
+		uuid: Args.string({
+			description: 'comma-separated list (no blank spaces) of device UUIDs',
+			required: true,
+		}),
+		service: Args.string({
+			description: 'comma-separated list (no blank spaces) of service names',
+			required: true,
+		}),
+	};
+
+	public static usage = 'device start-service <uuid>';
+
+	public static flags = {
+		help: cf.help,
+	};
+
+	public static authenticated = true;
+
+	public async run() {
+		const { args: params } = await this.parse(DeviceStartServiceCmd);
+
+		const balena = getBalenaSdk();
+		const ux = getCliUx();
+
+		const deviceUuids = params.uuid.split(',');
+		const serviceNames = params.service.split(',');
+
+		// Iterate sequentially through deviceUuids.
+		// We may later want to add a batching feature,
+		// so that n devices are processed in parallel
+		for (const uuid of deviceUuids) {
+			ux.action.start(`Starting services on device ${uuid}`);
+			await this.startServices(balena, uuid, serviceNames);
+			ux.action.stop();
+		}
+	}
+
+	async startServices(
+		balena: BalenaSDK,
+		deviceUuid: string,
+		serviceNames: string[],
+	) {
+		const { ExpectedError } = await import('../../errors');
+		const { getExpandedProp } = await import('../../utils/pine');
+
+		// Get device
+		const device = await balena.models.device.getWithServiceDetails(
+			deviceUuid,
+			{
+				$expand: {
+					is_running__release: { $select: 'commit' },
+				},
+			},
+		);
+
+		const activeReleaseCommit = getExpandedProp(
+			device.is_running__release,
+			'commit',
+		);
+
+		// Check specified services exist on this device before startinganything
+		serviceNames.forEach((service) => {
+			if (!device.current_services[service]) {
+				throw new ExpectedError(
+					`Service ${service} not found on device ${deviceUuid}.`,
+				);
+			}
+		});
+
+		// Start services
+		const startPromises: Array<Promise<void>> = [];
+		for (const serviceName of serviceNames) {
+			const service = device.current_services[serviceName];
+			// Each service is an array of `CurrentServiceWithCommit`
+			// because when service is updating, it will actually hold 2 services
+			// Target commit matching `device.is_running__release`
+			const serviceContainer = service.find((s) => {
+				return s.commit === activeReleaseCommit;
+			});
+
+			if (serviceContainer) {
+				startPromises.push(
+					balena.models.device.startService(
+						deviceUuid,
+						serviceContainer.image_id,
+					),
+				);
+			}
+		}
+
+		try {
+			await Promise.all(startPromises);
+		} catch (e) {
+			if (e.message.toLowerCase().includes('no online device')) {
+				throw new ExpectedError(`Device ${deviceUuid} is not online.`);
+			} else {
+				throw e;
+			}
+		}
+	}
+}

lib/commands/device/stop-service.ts

@@ -0,0 +1,139 @@
+/**
+ * @license
+ * Copyright 2016-2020 Balena Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { Args } from '@oclif/core';
+import Command from '../../command';
+import * as cf from '../../utils/common-flags';
+import { getBalenaSdk, getCliUx, stripIndent } from '../../utils/lazy';
+import type { BalenaSDK } from 'balena-sdk';
+
+export default class DeviceStopServiceCmd extends Command {
+	public static description = stripIndent`
+		Stop containers on a device.
+
+		Stop containers on a device.
+
+		Multiple devices and services may be specified with a comma-separated list
+		of values (no spaces).
+		`;
+	public static examples = [
+		'$ balena device stop-service 23c73a1 myService',
+		'$ balena device stop-service 23c73a1 myService1,myService2',
+	];
+
+	public static args = {
+		uuid: Args.string({
+			description: 'comma-separated list (no blank spaces) of device UUIDs',
+			required: true,
+		}),
+		service: Args.string({
+			description: 'comma-separated list (no blank spaces) of service names',
+			required: true,
+		}),
+	};
+
+	public static usage = 'device stop-service <uuid>';
+
+	public static flags = {
+		help: cf.help,
+	};
+
+	public static authenticated = true;
+
+	public async run() {
+		const { args: params } = await this.parse(DeviceStopServiceCmd);
+
+		const balena = getBalenaSdk();
+		const ux = getCliUx();
+
+		const deviceUuids = params.uuid.split(',');
+		const serviceNames = params.service.split(',');
+
+		// Iterate sequentially through deviceUuids.
+		// We may later want to add a batching feature,
+		// so that n devices are processed in parallel
+		for (const uuid of deviceUuids) {
+			ux.action.start(`Stopping services on device ${uuid}`);
+			await this.stopServices(balena, uuid, serviceNames);
+			ux.action.stop();
+		}
+	}
+
+	async stopServices(
+		balena: BalenaSDK,
+		deviceUuid: string,
+		serviceNames: string[],
+	) {
+		const { ExpectedError } = await import('../../errors');
+		const { getExpandedProp } = await import('../../utils/pine');
+
+		// Get device
+		const device = await balena.models.device.getWithServiceDetails(
+			deviceUuid,
+			{
+				$expand: {
+					is_running__release: { $select: 'commit' },
+				},
+			},
+		);
+
+		const activeReleaseCommit = getExpandedProp(
+			device.is_running__release,
+			'commit',
+		);
+
+		// Check specified services exist on this device before stoppinganything
+		serviceNames.forEach((service) => {
+			if (!device.current_services[service]) {
+				throw new ExpectedError(
+					`Service ${service} not found on device ${deviceUuid}.`,
+				);
+			}
+		});
+
+		// Stop services
+		const stopPromises: Array<Promise<void>> = [];
+		for (const serviceName of serviceNames) {
+			const service = device.current_services[serviceName];
+			// Each service is an array of `CurrentServiceWithCommit`
+			// because when service is updating, it will actually hold 2 services
+			// Target commit matching `device.is_running__release`
+			const serviceContainer = service.find((s) => {
+				return s.commit === activeReleaseCommit;
+			});
+
+			if (serviceContainer) {
+				stopPromises.push(
+					balena.models.device.stopService(
+						deviceUuid,
+						serviceContainer.image_id,
+					),
+				);
+			}
+		}
+
+		try {
+			await Promise.all(stopPromises);
+		} catch (e) {
+			if (e.message.toLowerCase().includes('no online device')) {
+				throw new ExpectedError(`Device ${deviceUuid} is not online.`);
+			} else {
+				throw e;
+			}
+		}
+	}
+}

lib/commands/device/track-fleet.ts

@@ -0,0 +1,53 @@
+/**
+ * @license
+ * Copyright 2016-2020 Balena Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { Args } from '@oclif/core';
+import Command from '../../command';
+import * as cf from '../../utils/common-flags';
+import { getBalenaSdk, stripIndent } from '../../utils/lazy';
+
+export default class DeviceTrackFleetCmd extends Command {
+	public static description = stripIndent`
+		Make a device track the fleet's pinned release.
+
+		Make a device track the fleet's pinned release.
+		`;
+	public static examples = ['$ balena device track-fleet 7cf02a6'];
+
+	public static args = {
+		uuid: Args.string({
+			description: "the uuid of the device to make track the fleet's release",
+			required: true,
+		}),
+	};
+
+	public static usage = 'device track-fleet <uuid>';
+
+	public static flags = {
+		help: cf.help,
+	};
+
+	public static authenticated = true;
+
+	public async run() {
+		const { args: params } = await this.parse(DeviceTrackFleetCmd);
+
+		const balena = getBalenaSdk();
+
+		await balena.models.device.trackApplicationRelease(params.uuid);
+	}
+}

lib/commands/devices/index.ts

@@ -15,26 +15,25 @@
  * limitations under the License.
  */
 
-import { flags } from '@oclif/command';
 import Command from '../../command';
 import * as cf from '../../utils/common-flags';
 import { expandForAppName } from '../../utils/helpers';
 import { getBalenaSdk, getVisuals, stripIndent } from '../../utils/lazy';
 import { applicationIdInfo, jsonInfo } from '../../utils/messages';
 
-import type { Application } from 'balena-sdk';
+import type { Device, PineOptions } from 'balena-sdk';
 
-interface ExtendedDevice extends DeviceWithDeviceType {
-	dashboard_url?: string;
-	fleet?: string | null; // 'org/name' slug
-	device_type?: string | null;
-}
-
-interface FlagsDef {
-	fleet?: string;
-	help: void;
-	json: boolean;
-}
+const devicesSelectFields = {
+	$select: [
+		'id',
+		'uuid',
+		'device_name',
+		'status',
+		'is_online',
+		'supervisor_version',
+		'os_version',
+	],
+} satisfies PineOptions<Device>;
 
 export default class DevicesCmd extends Command {
 	public static description = stripIndent`
@@ -56,7 +55,7 @@ export default class DevicesCmd extends Command {
 
 	public static usage = 'devices';
 
-	public static flags: flags.Input<FlagsDef> = {
+	public static flags = {
 		fleet: cf.fleet,
 		json: cf.json,
 		help: cf.help,
@@ -67,39 +66,42 @@ export default class DevicesCmd extends Command {
 	public static authenticated = true;
 
 	public async run() {
-		const { flags: options } = this.parse<FlagsDef, {}>(DevicesCmd);
+		const { flags: options } = await this.parse(DevicesCmd);
 
 		const balena = getBalenaSdk();
+		const devicesOptions = {
+			...devicesSelectFields,
+			...expandForAppName,
+			$orderby: { device_name: 'asc' },
+		} satisfies PineOptions<Device>;
 
-		let devices;
+		const devices = (
+			await (async () => {
+				if (options.fleet != null) {
+					const { getApplication } = await import('../../utils/sdk');
+					const application = await getApplication(balena, options.fleet, {
+						$select: 'slug',
+						$expand: {
+							owns__device: devicesOptions,
+						},
+					});
+					return application.owns__device;
+				}
 
-		if (options.fleet != null) {
-			const { getApplication } = await import('../../utils/sdk');
-			const application = await getApplication(balena, options.fleet);
-			devices = (await balena.models.device.getAllByApplication(
-				application.id,
-				expandForAppName,
-			)) as ExtendedDevice[];
-		} else {
-			devices = (await balena.models.device.getAll(
-				expandForAppName,
-			)) as ExtendedDevice[];
-		}
+				return await balena.pine.get({
+					resource: 'device',
+					options: devicesOptions,
+				});
+			})()
+		).map((device) => ({
+			...device,
+			dashboard_url: balena.models.device.getDashboardUrl(device.uuid),
+			fleet: device.belongs_to__application?.[0]?.slug || null,
+			uuid: options.json ? device.uuid : device.uuid.slice(0, 7),
+			device_type: device.is_of__device_type?.[0]?.slug || null,
+		}));
 
-		devices = devices.map(function (device) {
-			device.dashboard_url = balena.models.device.getDashboardUrl(device.uuid);
-
-			const belongsToApplication =
-				device.belongs_to__application as Application[];
-			device.fleet = belongsToApplication?.[0]?.slug || null;
-
-			device.uuid = options.json ? device.uuid : device.uuid.slice(0, 7);
-
-			device.device_type = device.is_of__device_type?.[0]?.slug || null;
-			return device;
-		});
-
-		const fields = [
+		const fields: Array<keyof (typeof devices)[number]> = [
 			'id',
 			'uuid',
 			'device_name',

lib/commands/devices/supported.ts

@@ -14,7 +14,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { flags } from '@oclif/command';
+import { Flags } from '@oclif/core';
+import type * as BalenaSdk from 'balena-sdk';
 import * as _ from 'lodash';
 import Command from '../../command';
 
@@ -22,11 +23,6 @@ import * as cf from '../../utils/common-flags';
 import { getBalenaSdk, getVisuals, stripIndent } from '../../utils/lazy';
 import { CommandHelp } from '../../utils/oclif-utils';
 
-interface FlagsDef {
-	help: void;
-	json?: boolean;
-}
-
 export default class DevicesSupportedCmd extends Command {
 	public static description = stripIndent`
 		List the supported device types (like 'raspberrypi3' or 'intel-nuc').
@@ -49,46 +45,48 @@ export default class DevicesSupportedCmd extends Command {
 		new CommandHelp({ args: DevicesSupportedCmd.args }).defaultUsage()
 	).trim();
 
-	public static flags: flags.Input<FlagsDef> = {
+	public static flags = {
 		help: cf.help,
-		json: flags.boolean({
+		json: Flags.boolean({
 			char: 'j',
 			description: 'produce JSON output instead of tabular output',
 		}),
 	};
 
 	public async run() {
-		const { flags: options } = this.parse<FlagsDef, {}>(DevicesSupportedCmd);
-		const [dts, configDTs] = await Promise.all([
-			getBalenaSdk().models.deviceType.getAllSupported({
-				$expand: { is_of__cpu_architecture: { $select: 'slug' } },
-				$select: ['slug', 'name'],
-			}),
-			getBalenaSdk().models.config.getDeviceTypes(),
-		]);
-		const dtsBySlug = _.keyBy(dts, (dt) => dt.slug);
-		const configDTsBySlug = _.keyBy(configDTs, (dt) => dt.slug);
+		const { flags: options } = await this.parse(DevicesSupportedCmd);
+		const pineOptions = {
+			$select: ['slug', 'name'],
+			$expand: {
+				is_of__cpu_architecture: { $select: 'slug' },
+				device_type_alias: {
+					$select: 'is_referenced_by__alias',
+					$orderby: { is_referenced_by__alias: 'asc' },
+				},
+			},
+		} satisfies BalenaSdk.PineOptions<BalenaSdk.DeviceType>;
+		const dts = (await getBalenaSdk().models.deviceType.getAllSupported(
+			pineOptions,
+		)) as Array<
+			BalenaSdk.PineTypedResult<BalenaSdk.DeviceType, typeof pineOptions>
+		>;
 		interface DT {
 			slug: string;
 			aliases: string[];
 			arch: string;
 			name: string;
 		}
-		let deviceTypes: DT[] = [];
-		for (const slug of Object.keys(dtsBySlug)) {
-			const configDT: Partial<typeof configDTs[0]> =
-				configDTsBySlug[slug] || {};
-			const aliases = (configDT.aliases || []).filter(
-				(alias) => alias !== slug,
-			);
-			const dt: Partial<typeof dts[0]> = dtsBySlug[slug] || {};
-			deviceTypes.push({
-				slug,
+		let deviceTypes = dts.map((dt): DT => {
+			const aliases = dt.device_type_alias
+				.map((dta) => dta.is_referenced_by__alias)
+				.filter((alias) => alias !== dt.slug);
+			return {
+				slug: dt.slug,
 				aliases: options.json ? aliases : [aliases.join(', ')],
-				arch: (dt.is_of__cpu_architecture as any)?.[0]?.slug || 'n/a',
+				arch: dt.is_of__cpu_architecture[0]?.slug || 'n/a',
 				name: dt.name || 'N/A',
-			});
-		}
+			};
+		});
 		const fields = ['slug', 'aliases', 'arch', 'name'];
 		deviceTypes = _.sortBy(deviceTypes, fields);
 		if (options.json) {

lib/commands/env/add.ts

@@ -15,7 +15,7 @@
  * limitations under the License.
  */
 
-import { flags } from '@oclif/command';
+import { Args } from '@oclif/core';
 import type * as BalenaSdk from 'balena-sdk';
 import Command from '../../command';
 import { ExpectedError } from '../../errors';
@@ -78,23 +78,23 @@ export default class EnvAddCmd extends Command {
 		'$ balena env add EDITOR vim --device 7cf02a6,d6f1433 --service MyService,MyService2',
 	];
 
-	public static args = [
-		{
-			name: 'name',
+	public static args = {
+		name: Args.string({
 			required: true,
 			description: 'environment or config variable name',
-		},
-		{
-			name: 'value',
+		}),
+		value: Args.string({
 			required: false,
 			description:
 				"variable value; if omitted, use value from this process' environment",
-		},
-	];
+		}),
+	};
 
+	// Required for supporting empty string ('') `value` args.
+	public static strict = false;
 	public static usage = 'env add <name> [value]';
 
-	public static flags: flags.Input<FlagsDef> = {
+	public static flags = {
 		fleet: { ...cf.fleet, exclusive: ['device'] },
 		device: { ...cf.device, exclusive: ['fleet'] },
 		help: cf.help,
@@ -103,9 +103,7 @@ export default class EnvAddCmd extends Command {
 	};
 
 	public async run() {
-		const { args: params, flags: options } = this.parse<FlagsDef, ArgsDef>(
-			EnvAddCmd,
-		);
+		const { args: params, flags: options } = await this.parse(EnvAddCmd);
 		const cmd = this;
 
 		if (!options.fleet && !options.device) {
@@ -151,16 +149,15 @@ export default class EnvAddCmd extends Command {
 
 		const varType = isConfigVar ? 'configVar' : 'envVar';
 		if (options.fleet) {
-			const { getFleetSlug } = await import('../../utils/sdk');
-			for (const app of options.fleet.split(',')) {
+			for (const appSlug of await resolveFleetSlugs(balena, options.fleet)) {
 				try {
 					await balena.models.application[varType].set(
-						await getFleetSlug(balena, app),
+						appSlug,
 						params.name,
 						params.value,
 					);
 				} catch (err) {
-					console.error(`${err.message}, fleet: ${app}`);
+					console.error(`${err.message}, fleet: ${appSlug}`);
 					process.exitCode = 1;
 				}
 			}
@@ -181,6 +178,25 @@ export default class EnvAddCmd extends Command {
 	}
 }
 
+// TODO: Stop accepting application names in the next major
+// and just drop this in favor of doing the .split(',') directly.
+async function resolveFleetSlugs(
+	balena: BalenaSdk.BalenaSDK,
+	fleetOption: string,
+) {
+	const fleetSlugs: string[] = [];
+	const { getFleetSlug } = await import('../../utils/sdk');
+	for (const appNameOrSlug of fleetOption.split(',')) {
+		try {
+			fleetSlugs.push(await getFleetSlug(balena, appNameOrSlug));
+		} catch (err) {
+			console.error(`${err.message}, fleet: ${appNameOrSlug}`);
+			process.exitCode = 1;
+		}
+	}
+	return fleetSlugs;
+}
+
 /**
  * Add service variables for a device or fleet.
  */
@@ -190,17 +206,17 @@ async function setServiceVars(
 	options: FlagsDef,
 ) {
 	if (options.fleet) {
-		for (const app of options.fleet.split(',')) {
+		for (const appSlug of await resolveFleetSlugs(sdk, options.fleet)) {
 			for (const service of options.service!.split(',')) {
 				try {
-					const serviceId = await getServiceIdForApp(sdk, app, service);
+					const serviceId = await getServiceIdForApp(sdk, appSlug, service);
 					await sdk.models.service.var.set(
 						serviceId,
 						params.name,
 						params.value!,
 					);
 				} catch (err) {
-					console.error(`${err.message}, fleet: ${app}`);
+					console.error(`${err.message}, fleet: ${appSlug}`);
 					process.exitCode = 1;
 				}
 			}
@@ -245,11 +261,12 @@ async function setServiceVars(
  */
 async function getServiceIdForApp(
 	sdk: BalenaSdk.BalenaSDK,
-	appName: string,
+	appSlug: string,
 	serviceName: string,
 ): Promise<number> {
 	let serviceId: number | undefined;
-	const services = await sdk.models.service.getAllByApplication(appName, {
+	const services = await sdk.models.service.getAllByApplication(appSlug, {
+		$select: 'id',
 		$filter: { service_name: serviceName },
 	});
 	if (services.length > 0) {
@@ -257,7 +274,7 @@ async function getServiceIdForApp(
 	}
 	if (serviceId === undefined) {
 		throw new ExpectedError(
-			`Cannot find service ${serviceName} for fleet ${appName}`,
+			`Cannot find service ${serviceName} for fleet ${appSlug}`,
 		);
 	}
 	return serviceId;

lib/commands/env/rename.ts

@@ -14,7 +14,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { flags } from '@oclif/command';
+import { Args } from '@oclif/core';
 import Command from '../../command';
 
 import * as cf from '../../utils/common-flags';
@@ -22,20 +22,6 @@ import * as ec from '../../utils/env-common';
 import { getBalenaSdk, stripIndent } from '../../utils/lazy';
 import { parseAsInteger } from '../../utils/validation';
 
-type IArg<T> = import('@oclif/parser').args.IArg<T>;
-
-interface FlagsDef {
-	config: boolean;
-	device: boolean;
-	service: boolean;
-	help: void;
-}
-
-interface ArgsDef {
-	id: number;
-	value: string;
-}
-
 export default class EnvRenameCmd extends Command {
 	public static description = stripIndent`
 		Change the value of a config or env var for a fleet, device or service.
@@ -54,24 +40,22 @@ export default class EnvRenameCmd extends Command {
 		'$ balena env rename 678678 1 --device --config',
 	];
 
-	public static args: Array<IArg<any>> = [
-		{
-			name: 'id',
+	public static args = {
+		id: Args.integer({
 			required: true,
 			description: "variable's numeric database ID",
-			parse: (input) => parseAsInteger(input, 'id'),
-		},
-		{
-			name: 'value',
+			parse: async (input) => parseAsInteger(input, 'id'),
+		}),
+		value: Args.string({
 			required: true,
 			description:
 				"variable value; if omitted, use value from this process' environment",
-		},
-	];
+		}),
+	};
 
 	public static usage = 'env rename <id> <value>';
 
-	public static flags: flags.Input<FlagsDef> = {
+	public static flags = {
 		config: ec.booleanConfig,
 		device: ec.booleanDevice,
 		service: ec.booleanService,
@@ -79,9 +63,7 @@ export default class EnvRenameCmd extends Command {
 	};
 
 	public async run() {
-		const { args: params, flags: opt } = this.parse<FlagsDef, ArgsDef>(
-			EnvRenameCmd,
-		);
+		const { args: params, flags: opt } = await this.parse(EnvRenameCmd);
 
 		await Command.checkLoggedIn();
 

lib/commands/env/rm.ts

@@ -15,26 +15,13 @@
  * limitations under the License.
  */
 
-import { flags } from '@oclif/command';
+import { Flags, Args } from '@oclif/core';
 import Command from '../../command';
 
 import * as ec from '../../utils/env-common';
 import { getBalenaSdk, stripIndent } from '../../utils/lazy';
 import { parseAsInteger } from '../../utils/validation';
 
-type IArg<T> = import('@oclif/parser').args.IArg<T>;
-
-interface FlagsDef {
-	config: boolean;
-	device: boolean;
-	service: boolean;
-	yes: boolean;
-}
-
-interface ArgsDef {
-	id: number;
-}
-
 export default class EnvRmCmd extends Command {
 	public static description = stripIndent`
 		Remove a config or env var from a fleet, device or service.
@@ -57,22 +44,21 @@ export default class EnvRmCmd extends Command {
 		'$ balena env rm 789789 --device --service --yes',
 	];
 
-	public static args: Array<IArg<any>> = [
-		{
-			name: 'id',
+	public static args = {
+		id: Args.integer({
 			required: true,
 			description: "variable's numeric database ID",
-			parse: (input) => parseAsInteger(input, 'id'),
-		},
-	];
+			parse: async (input) => parseAsInteger(input, 'id'),
+		}),
+	};
 
 	public static usage = 'env rm <id>';
 
-	public static flags: flags.Input<FlagsDef> = {
+	public static flags = {
 		config: ec.booleanConfig,
 		device: ec.booleanDevice,
 		service: ec.booleanService,
-		yes: flags.boolean({
+		yes: Flags.boolean({
 			char: 'y',
 			description:
 				'do not prompt for confirmation before deleting the variable',
@@ -81,9 +67,7 @@ export default class EnvRmCmd extends Command {
 	};
 
 	public async run() {
-		const { args: params, flags: opt } = this.parse<FlagsDef, ArgsDef>(
-			EnvRmCmd,
-		);
+		const { args: params, flags: opt } = await this.parse(EnvRmCmd);
 
 		await Command.checkLoggedIn();
 

lib/commands/envs/index.ts

@@ -14,23 +14,17 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { flags } from '@oclif/command';
+import { Flags } from '@oclif/core';
+import type { Interfaces } from '@oclif/core';
 import type * as SDK from 'balena-sdk';
 import * as _ from 'lodash';
-import Command from '../command';
-import { ExpectedError } from '../errors';
-import * as cf from '../utils/common-flags';
-import { getBalenaSdk, getVisuals, stripIndent } from '../utils/lazy';
-import { applicationIdInfo } from '../utils/messages';
+import Command from '../../command';
+import { ExpectedError } from '../../errors';
+import * as cf from '../../utils/common-flags';
+import { getBalenaSdk, getVisuals, stripIndent } from '../../utils/lazy';
+import { applicationIdInfo } from '../../utils/messages';
 
-interface FlagsDef {
-	fleet?: string;
-	config: boolean;
-	device?: string; // device UUID
-	json: boolean;
-	help: void;
-	service?: string; // service name
-}
+type FlagsDef = Interfaces.InferredFlags<typeof EnvsCmd.flags>;
 
 interface EnvironmentVariableInfo extends SDK.EnvironmentVariableBase {
 	fleet?: string | null; // fleet slug
@@ -93,7 +87,6 @@ export default class EnvsCmd extends Command {
 		'$ balena envs --fleet myorg/myfleet',
 		'$ balena envs --fleet MyFleet --json',
 		'$ balena envs --fleet MyFleet --service MyService',
-		'$ balena envs --fleet MyFleet --service MyService',
 		'$ balena envs --fleet MyFleet --config',
 		'$ balena envs --device 7cf02a6',
 		'$ balena envs --device 7cf02a6 --json',
@@ -103,9 +96,9 @@ export default class EnvsCmd extends Command {
 
 	public static usage = 'envs';
 
-	public static flags: flags.Input<FlagsDef> = {
+	public static flags = {
 		fleet: { ...cf.fleet, exclusive: ['device'] },
-		config: flags.boolean({
+		config: Flags.boolean({
 			default: false,
 			char: 'c',
 			description: 'show configuration variables only',
@@ -118,7 +111,7 @@ export default class EnvsCmd extends Command {
 	};
 
 	public async run() {
-		const { flags: options } = this.parse<FlagsDef, {}>(EnvsCmd);
+		const { flags: options } = await this.parse(EnvsCmd);
 
 		const variables: EnvironmentVariableInfo[] = [];
 
@@ -131,12 +124,16 @@ export default class EnvsCmd extends Command {
 		const balena = getBalenaSdk();
 
 		let fleetSlug: string | undefined = options.fleet
-			? await (await import('../utils/sdk')).getFleetSlug(balena, options.fleet)
+			? await (
+					await import('../../utils/sdk')
+			  ).getFleetSlug(balena, options.fleet)
 			: undefined;
 		let fullUUID: string | undefined; // as oppposed to the short, 7-char UUID
 
 		if (options.device) {
-			const { getDeviceAndMaybeAppFromUUID } = await import('../utils/cloud');
+			const { getDeviceAndMaybeAppFromUUID } = await import(
+				'../../utils/cloud'
+			);
 			const [device, app] = await getDeviceAndMaybeAppFromUUID(
 				balena,
 				options.device,
@@ -189,7 +186,7 @@ export default class EnvsCmd extends Command {
 		}
 
 		if (options.json) {
-			const { pickAndRename } = await import('../utils/helpers');
+			const { pickAndRename } = await import('../../utils/helpers');
 			const mapped = varArray.map((o) => pickAndRename(o, fields));
 			this.log(JSON.stringify(mapped, null, 4));
 		} else {
@@ -209,6 +206,7 @@ async function validateServiceName(
 	fleetSlug: string,
 ) {
 	const services = await sdk.models.service.getAllByApplication(fleetSlug, {
+		$select: 'id',
 		$filter: { service_name: serviceName },
 	});
 	if (services.length === 0) {
@@ -234,9 +232,10 @@ async function getAppVars(
 	if (!fleetSlug) {
 		return appVars;
 	}
-	const vars = await sdk.models.application[
-		options.config ? 'configVar' : 'envVar'
-	].getAllByApplication(fleetSlug);
+	const vars =
+		await sdk.models.application[
+			options.config ? 'configVar' : 'envVar'
+		].getAllByApplication(fleetSlug);
 	fillInInfoFields(vars, fleetSlug);
 	appVars.push(...vars);
 	if (!options.config) {
@@ -275,9 +274,8 @@ async function getDeviceVars(
 	const printedUUID = options.json ? fullUUID : options.device!;
 	const deviceVars: EnvironmentVariableInfo[] = [];
 	if (options.config) {
-		const deviceConfigVars = await sdk.models.device.configVar.getAllByDevice(
-			fullUUID,
-		);
+		const deviceConfigVars =
+			await sdk.models.device.configVar.getAllByDevice(fullUUID);
 		fillInInfoFields(deviceConfigVars, fleetSlug, printedUUID);
 		deviceVars.push(...deviceConfigVars);
 	} else {
@@ -302,9 +300,8 @@ async function getDeviceVars(
 		fillInInfoFields(deviceServiceVars, fleetSlug, printedUUID);
 		deviceVars.push(...deviceServiceVars);
 
-		const deviceEnvVars = await sdk.models.device.envVar.getAllByDevice(
-			fullUUID,
-		);
+		const deviceEnvVars =
+			await sdk.models.device.envVar.getAllByDevice(fullUUID);
 		fillInInfoFields(deviceEnvVars, fleetSlug, printedUUID);
 		deviceVars.push(...deviceEnvVars);
 	}

lib/commands/fleet/create.ts

@@ -15,23 +15,11 @@
  * limitations under the License.
  */
 
-import { flags } from '@oclif/command';
-import type { Application } from 'balena-sdk';
+import { Flags, Args } from '@oclif/core';
 
 import Command from '../../command';
-import { ExpectedError } from '../../errors';
 import * as cf from '../../utils/common-flags';
-import { getBalenaSdk, stripIndent } from '../../utils/lazy';
-
-interface FlagsDef {
-	organization?: string;
-	type?: string; // application device type
-	help: void;
-}
-
-interface ArgsDef {
-	name: string;
-}
+import { stripIndent } from '../../utils/lazy';
 
 export default class FleetCreateCmd extends Command {
 	public static description = stripIndent`
@@ -61,22 +49,21 @@ export default class FleetCreateCmd extends Command {
 		'$ balena fleet create MyFleet -o myorg --type raspberry-pi',
 	];
 
-	public static args = [
-		{
-			name: 'name',
+	public static args = {
+		name: Args.string({
 			description: 'fleet name',
 			required: true,
-		},
-	];
+		}),
+	};
 
 	public static usage = 'fleet create <name>';
 
-	public static flags: flags.Input<FlagsDef> = {
-		organization: flags.string({
+	public static flags = {
+		organization: Flags.string({
 			char: 'o',
 			description: 'handle of the organization the fleet should belong to',
 		}),
-		type: flags.string({
+		type: Flags.string({
 			char: 't',
 			description:
 				'fleet device type (Check available types with `balena devices supported`)',
@@ -87,63 +74,10 @@ export default class FleetCreateCmd extends Command {
 	public static authenticated = true;
 
 	public async run() {
-		const { args: params, flags: options } = this.parse<FlagsDef, ArgsDef>(
-			FleetCreateCmd,
-		);
+		const { args: params, flags: options } = await this.parse(FleetCreateCmd);
 
-		// Ascertain device type
-		const deviceType =
-			options.type ||
-			(await (await import('../../utils/patterns')).selectDeviceType());
-
-		// Ascertain organization
-		const organization =
-			options.organization?.toLowerCase() || (await this.getOrganization());
-
-		// Create application
-		let application: Application;
-		try {
-			application = await getBalenaSdk().models.application.create({
-				name: params.name,
-				deviceType,
-				organization,
-			});
-		} catch (err) {
-			if ((err.message || '').toLowerCase().includes('unique')) {
-				// BalenaRequestError: Request error: "organization" and "app_name" must be unique.
-				throw new ExpectedError(
-					`Error: fleet "${params.name}" already exists in organization "${organization}".`,
-				);
-			} else if ((err.message || '').toLowerCase().includes('unauthorized')) {
-				// BalenaRequestError: Request error: Unauthorized
-				throw new ExpectedError(
-					`Error: You are not authorized to create fleets in organization "${organization}".`,
-				);
-			}
-
-			throw err;
-		}
-
-		// Output
-		console.log(
-			`Fleet created: slug "${application.slug}", device type "${deviceType}"`,
-		);
-	}
-
-	async getOrganization() {
-		const { getOwnOrganizations } = await import('../../utils/sdk');
-		const organizations = await getOwnOrganizations(getBalenaSdk());
-
-		if (organizations.length === 0) {
-			// User is not a member of any organizations (should not happen).
-			throw new Error('This account is not a member of any organizations');
-		} else if (organizations.length === 1) {
-			// User is a member of only one organization - use this.
-			return organizations[0].handle;
-		} else {
-			// User is a member of multiple organizations -
-			const { selectOrganization } = await import('../../utils/patterns');
-			return selectOrganization(organizations);
-		}
+		await (
+			await import('../../utils/application-create')
+		).applicationCreateBase('fleet', options, params);
 	}
 }

lib/commands/fleet/index.ts

@@ -15,24 +15,13 @@
  * limitations under the License.
  */
 
-import type { flags } from '@oclif/command';
-import type { Release } from 'balena-sdk';
+import { Flags } from '@oclif/core';
 
 import Command from '../../command';
 import * as cf from '../../utils/common-flags';
 import * as ca from '../../utils/common-args';
-import { getBalenaSdk, getVisuals, stripIndent } from '../../utils/lazy';
+import { getBalenaSdk, stripIndent } from '../../utils/lazy';
 import { applicationIdInfo } from '../../utils/messages';
-import { isV14 } from '../../utils/version';
-import type { DataOutputOptions } from '../../framework';
-
-interface FlagsDef extends DataOutputOptions {
-	help: void;
-}
-
-interface ArgsDef {
-	fleet: string;
-}
 
 export default class FleetCmd extends Command {
 	public static description = stripIndent`
@@ -45,59 +34,60 @@ export default class FleetCmd extends Command {
 	public static examples = [
 		'$ balena fleet MyFleet',
 		'$ balena fleet myorg/myfleet',
+		'$ balena fleet myorg/myfleet --view',
 	];
 
-	public static args = [ca.fleetRequired];
+	public static args = {
+		fleet: ca.fleetRequired,
+	};
 
 	public static usage = 'fleet <fleet>';
 
-	public static flags: flags.Input<FlagsDef> = {
+	public static flags = {
 		help: cf.help,
-		...(isV14() ? cf.dataOutputFlags : {}),
+		view: Flags.boolean({
+			default: false,
+			description: 'open fleet dashboard page',
+		}),
+		...cf.dataOutputFlags,
 	};
 
 	public static authenticated = true;
 	public static primary = true;
 
 	public async run() {
-		const { args: params, flags: options } = this.parse<FlagsDef, ArgsDef>(
-			FleetCmd,
-		);
+		const { args: params, flags: options } = await this.parse(FleetCmd);
 
 		const { getApplication } = await import('../../utils/sdk');
 
-		const application = (await getApplication(getBalenaSdk(), params.fleet, {
+		const balena = getBalenaSdk();
+
+		const application = await getApplication(balena, params.fleet, {
 			$expand: {
 				is_for__device_type: { $select: 'slug' },
 				should_be_running__release: { $select: 'commit' },
 			},
-		})) as ApplicationWithDeviceType & {
-			should_be_running__release: [Release?];
-			// For display purposes:
-			device_type: string;
-			commit?: string;
+		});
+
+		if (options.view) {
+			const open = await import('open');
+			const dashboardUrl = balena.models.application.getDashboardUrl(
+				application.id,
+			);
+			await open(dashboardUrl, { wait: false });
+			return;
+		}
+
+		const outputApplication = {
+			...application,
+			device_type: application.is_for__device_type[0].slug,
+			commit: application.should_be_running__release[0]?.commit,
 		};
 
-		application.device_type = application.is_for__device_type[0].slug;
-		application.commit = application.should_be_running__release[0]?.commit;
-
-		if (isV14()) {
-			await this.outputData(
-				application,
-				['app_name', 'id', 'device_type', 'slug', 'commit'],
-				options,
-			);
-		} else {
-			// Emulate table.vertical title output, but avoid uppercasing and inserting spaces
-			console.log(`== ${application.slug}`);
-			console.log(
-				getVisuals().table.vertical(application, [
-					'id',
-					'device_type',
-					'slug',
-					'commit',
-				]),
-			);
-		}
+		await this.outputData(
+			outputApplication,
+			['app_name', 'id', 'device_type', 'slug', 'commit'],
+			options,
+		);
 	}
 }

lib/commands/fleet/pin.ts

@@ -0,0 +1,88 @@
+/**
+ * @license
+ * Copyright 2016-2020 Balena Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { Args } from '@oclif/core';
+import Command from '../../command';
+import * as cf from '../../utils/common-flags';
+import { getBalenaSdk, stripIndent } from '../../utils/lazy';
+import { getExpandedProp } from '../../utils/pine';
+
+export default class FleetPinCmd extends Command {
+	public static description = stripIndent`
+		Pin a fleet to a release.
+
+		Pin a fleet to a release.
+
+		Note, if the commit is omitted, the currently pinned release will be printed, with instructions for how to see a list of releases
+		`;
+	public static examples = [
+		'$ balena fleet pin myfleet',
+		'$ balena fleet pin myorg/myfleet 91165e5',
+	];
+
+	public static args = {
+		slug: Args.string({
+			description: 'the slug of the fleet to pin to a release',
+			required: true,
+		}),
+		releaseToPinTo: Args.string({
+			description: 'the commit of the release for the fleet to get pinned to',
+		}),
+	};
+
+	public static usage = 'fleet pin <slug> [releaseToPinTo]';
+
+	public static flags = {
+		help: cf.help,
+	};
+
+	public static authenticated = true;
+
+	public async run() {
+		const { args: params } = await this.parse(FleetPinCmd);
+
+		const balena = getBalenaSdk();
+
+		const fleet = await balena.models.application.get(params.slug, {
+			$expand: {
+				should_be_running__release: {
+					$select: 'commit',
+				},
+			},
+		});
+
+		const pinnedRelease = getExpandedProp(
+			fleet.should_be_running__release,
+			'commit',
+		);
+
+		const releaseToPinTo = params.releaseToPinTo;
+		const slug = params.slug;
+
+		if (!releaseToPinTo) {
+			console.log(
+				`${
+					pinnedRelease
+						? `This fleet is currently pinned to ${pinnedRelease}.`
+						: 'This fleet is not currently pinned to any release.'
+				} \n\nTo see a list of all releases this fleet can be pinned to, run \`balena releases ${slug}\`.`,
+			);
+		} else {
+			await balena.models.application.pinToRelease(slug, releaseToPinTo);
+		}
+	}
+}

lib/commands/fleet/purge.ts

@@ -15,22 +15,12 @@
  * limitations under the License.
  */
 
-import type { flags } from '@oclif/command';
-
 import Command from '../../command';
 import * as cf from '../../utils/common-flags';
 import * as ca from '../../utils/common-args';
 import { getBalenaSdk, stripIndent } from '../../utils/lazy';
 import { applicationIdInfo } from '../../utils/messages';
 
-interface FlagsDef {
-	help: void;
-}
-
-interface ArgsDef {
-	fleet: string;
-}
-
 export default class FleetPurgeCmd extends Command {
 	public static description = stripIndent`
 		Purge data from a fleet.
@@ -46,18 +36,20 @@ export default class FleetPurgeCmd extends Command {
 		'$ balena fleet purge myorg/myfleet',
 	];
 
-	public static args = [ca.fleetRequired];
+	public static args = {
+		fleet: ca.fleetRequired,
+	};
 
 	public static usage = 'fleet purge <fleet>';
 
-	public static flags: flags.Input<FlagsDef> = {
+	public static flags = {
 		help: cf.help,
 	};
 
 	public static authenticated = true;
 
 	public async run() {
-		const { args: params } = this.parse<FlagsDef, ArgsDef>(FleetPurgeCmd);
+		const { args: params } = await this.parse(FleetPurgeCmd);
 
 		const { getApplication } = await import('../../utils/sdk');
 
@@ -65,7 +57,9 @@ export default class FleetPurgeCmd extends Command {
 
 		// balena.models.application.purge only accepts a numeric id
 		// so we must first fetch the app to get it's id,
-		const application = await getApplication(balena, params.fleet);
+		const application = await getApplication(balena, params.fleet, {
+			$select: 'id',
+		});
 
 		try {
 			await balena.models.application.purge(application.id);

lib/commands/fleet/rename.ts

@@ -15,8 +15,7 @@
  * limitations under the License.
  */
 
-import type { flags } from '@oclif/command';
-import type { ApplicationType } from 'balena-sdk';
+import { Args } from '@oclif/core';
 
 import Command from '../../command';
 import * as cf from '../../utils/common-flags';
@@ -24,15 +23,6 @@ import * as ca from '../../utils/common-args';
 import { getBalenaSdk, stripIndent, getCliForm } from '../../utils/lazy';
 import { applicationIdInfo } from '../../utils/messages';
 
-interface FlagsDef {
-	help: void;
-}
-
-interface ArgsDef {
-	fleet: string;
-	newName?: string;
-}
-
 export default class FleetRenameCmd extends Command {
 	public static description = stripIndent`
 		Rename a fleet.
@@ -51,24 +41,23 @@ export default class FleetRenameCmd extends Command {
 		'$ balena fleet rename myorg/oldname NewName',
 	];
 
-	public static args = [
-		ca.fleetRequired,
-		{
-			name: 'newName',
+	public static args = {
+		fleet: ca.fleetRequired,
+		newName: Args.string({
 			description: 'the new name for the fleet',
-		},
-	];
+		}),
+	};
 
 	public static usage = 'fleet rename <fleet> [newName]';
 
-	public static flags: flags.Input<FlagsDef> = {
+	public static flags = {
 		help: cf.help,
 	};
 
 	public static authenticated = true;
 
 	public async run() {
-		const { args: params } = this.parse<FlagsDef, ArgsDef>(FleetRenameCmd);
+		const { args: params } = await this.parse(FleetRenameCmd);
 
 		const { validateApplicationName } = await import('../../utils/validation');
 		const { ExpectedError } = await import('../../errors');
@@ -78,9 +67,10 @@ export default class FleetRenameCmd extends Command {
 		// Disambiguate target application (if params.params is a number, it could either be an ID or a numerical name)
 		const { getApplication } = await import('../../utils/sdk');
 		const application = await getApplication(balena, params.fleet, {
+			$select: ['id', 'app_name', 'slug'],
 			$expand: {
 				application_type: {
-					$select: ['is_legacy'],
+					$select: 'slug',
 				},
 			},
 		});
@@ -91,8 +81,8 @@ export default class FleetRenameCmd extends Command {
 		}
 
 		// Check app supports renaming
-		const appType = (application.application_type as ApplicationType[])?.[0];
-		if (appType.is_legacy) {
+		const appType = application.application_type[0];
+		if (appType.slug === 'legacy-v1' || appType.slug === 'legacy-v2') {
 			throw new ExpectedError(
 				`Fleet ${params.fleet} is of 'legacy' type, and cannot be renamed.`,
 			);
@@ -133,9 +123,9 @@ export default class FleetRenameCmd extends Command {
 		}
 
 		// Get application again, to be sure of results
-		const renamedApplication = await balena.models.application.get(
-			application.id,
-		);
+		const renamedApplication = await getApplication(balena, application.id, {
+			$select: ['app_name', 'slug'],
+		});
 
 		// Output result
 		console.log(`Fleet renamed`);

lib/commands/fleet/restart.ts

@@ -15,22 +15,12 @@
  * limitations under the License.
  */
 
-import type { flags } from '@oclif/command';
-
 import Command from '../../command';
 import * as cf from '../../utils/common-flags';
 import * as ca from '../../utils/common-args';
 import { getBalenaSdk, stripIndent } from '../../utils/lazy';
 import { applicationIdInfo } from '../../utils/messages';
 
-interface FlagsDef {
-	help: void;
-}
-
-interface ArgsDef {
-	fleet: string;
-}
-
 export default class FleetRestartCmd extends Command {
 	public static description = stripIndent`
 		Restart a fleet.
@@ -45,26 +35,30 @@ export default class FleetRestartCmd extends Command {
 		'$ balena fleet restart myorg/myfleet',
 	];
 
-	public static args = [ca.fleetRequired];
+	public static args = {
+		fleet: ca.fleetRequired,
+	};
 
 	public static usage = 'fleet restart <fleet>';
 
-	public static flags: flags.Input<FlagsDef> = {
+	public static flags = {
 		help: cf.help,
 	};
 
 	public static authenticated = true;
 
 	public async run() {
-		const { args: params } = this.parse<FlagsDef, ArgsDef>(FleetRestartCmd);
+		const { args: params } = await this.parse(FleetRestartCmd);
 
 		const { getApplication } = await import('../../utils/sdk');
 
 		const balena = getBalenaSdk();
 
-		// Disambiguate application (if is a number, it could either be an ID or a numerical name)
-		const application = await getApplication(balena, params.fleet);
+		// Disambiguate application
+		const application = await getApplication(balena, params.fleet, {
+			$select: 'slug',
+		});
 
-		await balena.models.application.restart(application.id);
+		await balena.models.application.restart(application.slug);
 	}
 }

lib/commands/fleet/rm.ts

@@ -15,23 +15,12 @@
  * limitations under the License.
  */
 
-import type { flags } from '@oclif/command';
-
 import Command from '../../command';
 import * as cf from '../../utils/common-flags';
 import * as ca from '../../utils/common-args';
 import { getBalenaSdk, stripIndent } from '../../utils/lazy';
 import { applicationIdInfo } from '../../utils/messages';
 
-interface FlagsDef {
-	yes: boolean;
-	help: void;
-}
-
-interface ArgsDef {
-	fleet: string;
-}
-
 export default class FleetRmCmd extends Command {
 	public static description = stripIndent`
 		Remove a fleet.
@@ -49,11 +38,13 @@ export default class FleetRmCmd extends Command {
 		'$ balena fleet rm myorg/myfleet',
 	];
 
-	public static args = [ca.fleetRequired];
+	public static args = {
+		fleet: ca.fleetRequired,
+	};
 
 	public static usage = 'fleet rm <fleet>';
 
-	public static flags: flags.Input<FlagsDef> = {
+	public static flags = {
 		yes: cf.yes,
 		help: cf.help,
 	};
@@ -61,9 +52,7 @@ export default class FleetRmCmd extends Command {
 	public static authenticated = true;
 
 	public async run() {
-		const { args: params, flags: options } = this.parse<FlagsDef, ArgsDef>(
-			FleetRmCmd,
-		);
+		const { args: params, flags: options } = await this.parse(FleetRmCmd);
 
 		const { confirm } = await import('../../utils/patterns');
 		const { getApplication } = await import('../../utils/sdk');
@@ -76,9 +65,11 @@ export default class FleetRmCmd extends Command {
 		);
 
 		// Disambiguate application (if is a number, it could either be an ID or a numerical name)
-		const application = await getApplication(balena, params.fleet);
+		const application = await getApplication(balena, params.fleet, {
+			$select: 'slug',
+		});
 
 		// Remove
-		await balena.models.application.remove(application.id);
+		await balena.models.application.remove(application.slug);
 	}
 }

lib/commands/fleet/track-latest.ts

@@ -0,0 +1,56 @@
+/**
+ * @license
+ * Copyright 2016-2020 Balena Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { Args } from '@oclif/core';
+import Command from '../../command';
+import * as cf from '../../utils/common-flags';
+import { getBalenaSdk, stripIndent } from '../../utils/lazy';
+
+export default class FleetTrackLatestCmd extends Command {
+	public static description = stripIndent`
+		Make this fleet track the latest release.
+
+		Make this fleet track the latest release.
+		`;
+	public static examples = [
+		'$ balena fleet track-latest myorg/myfleet',
+		'$ balena fleet track-latest myfleet',
+	];
+
+	public static args = {
+		slug: Args.string({
+			description: 'the slug of the fleet to make track the latest release',
+			required: true,
+		}),
+	};
+
+	public static usage = 'fleet track-latest <slug>';
+
+	public static flags = {
+		help: cf.help,
+	};
+
+	public static authenticated = true;
+
+	public async run() {
+		const { args: params } = await this.parse(FleetTrackLatestCmd);
+
+		const balena = getBalenaSdk();
+
+		await balena.models.application.trackLatestRelease(params.slug);
+	}
+}

lib/commands/fleets/index.ts

@@ -15,25 +15,18 @@
  * limitations under the License.
  */
 
-import { flags } from '@oclif/command';
+import type * as BalenaSdk from 'balena-sdk';
 
-import Command from '../command';
-import * as cf from '../utils/common-flags';
-import { getBalenaSdk, getVisuals, stripIndent } from '../utils/lazy';
-import { isV14 } from '../utils/version';
-import type { DataSetOutputOptions } from '../framework';
+import Command from '../../command';
+import * as cf from '../../utils/common-flags';
+import { getBalenaSdk, stripIndent } from '../../utils/lazy';
 
-interface ExtendedApplication extends ApplicationWithDeviceType {
+interface ExtendedApplication extends ApplicationWithDeviceTypeSlug {
 	device_count: number;
 	online_devices: number;
 	device_type?: string;
 }
 
-interface FlagsDef extends DataSetOutputOptions {
-	help: void;
-	verbose?: boolean;
-}
-
 export default class FleetsCmd extends Command {
 	public static description = stripIndent`
 		List all fleets.
@@ -48,8 +41,8 @@ export default class FleetsCmd extends Command {
 
 	public static usage = 'fleets';
 
-	public static flags: flags.Input<FlagsDef> = {
-		...(isV14() ? cf.dataSetOutputFlags : {}),
+	public static flags = {
+		...cf.dataSetOutputFlags,
 		help: cf.help,
 	};
 
@@ -57,19 +50,24 @@ export default class FleetsCmd extends Command {
 	public static primary = true;
 
 	public async run() {
-		const { flags: options } = this.parse<FlagsDef, {}>(FleetsCmd);
+		const { flags: options } = await this.parse(FleetsCmd);
 
 		const balena = getBalenaSdk();
 
+		const pineOptions = {
+			$select: ['id', 'app_name', 'slug'],
+			$expand: {
+				is_for__device_type: { $select: 'slug' },
+				owns__device: { $select: 'is_online' },
+			},
+		} satisfies BalenaSdk.PineOptions<BalenaSdk.Application>;
 		// Get applications
 		const applications =
-			(await balena.models.application.getAllDirectlyAccessible({
-				$select: ['id', 'app_name', 'slug'],
-				$expand: {
-					is_for__device_type: { $select: 'slug' },
-					owns__device: { $select: 'is_online' },
-				},
-			})) as ExtendedApplication[];
+			(await balena.models.application.getAllDirectlyAccessible(
+				pineOptions,
+			)) as Array<
+				BalenaSdk.PineTypedResult<BalenaSdk.Application, typeof pineOptions>
+			> as ExtendedApplication[];
 
 		// Add extended properties
 		applications.forEach((application) => {
@@ -79,30 +77,17 @@ export default class FleetsCmd extends Command {
 			application.device_type = application.is_for__device_type[0].slug;
 		});
 
-		if (isV14()) {
-			await this.outputData(
-				applications,
-				[
-					'id',
-					'app_name',
-					'slug',
-					'device_type',
-					'device_count',
-					'online_devices',
-				],
-				options,
-			);
-		} else {
-			console.log(
-				getVisuals().table.horizontal(applications, [
-					'id',
-					'app_name => NAME',
-					'slug',
-					'device_type',
-					'online_devices',
-					'device_count',
-				]),
-			);
-		}
+		await this.outputData(
+			applications,
+			[
+				'id',
+				'app_name',
+				'slug',
+				'device_type',
+				'device_count',
+				'online_devices',
+			],
+			options,
+		);
 	}
 }

lib/commands/internal/osinit.ts

@@ -15,6 +15,7 @@
  * limitations under the License.
  */
 
+import { Args } from '@oclif/core';
 import Command from '../../command';
 import { stripIndent } from '../../utils/lazy';
 import { CommandHelp } from '../../utils/oclif-utils';
@@ -27,12 +28,6 @@ import { CommandHelp } from '../../utils/oclif-utils';
 //    - https://github.com/balena-io/balena-cli/pull/1455#discussion_r334308357
 //    - https://github.com/balena-io/balena-cli/pull/1455#discussion_r334308526
 
-interface ArgsDef {
-	image: string;
-	type: string;
-	config: string;
-}
-
 export default class OsinitCmd extends Command {
 	public static description = stripIndent`
 		Do actual init of the device with the preconfigured os image.
@@ -41,20 +36,17 @@ export default class OsinitCmd extends Command {
 		Use \`balena os initialize <image>\` instead.
 	`;
 
-	public static args = [
-		{
-			name: 'image',
+	public static args = {
+		image: Args.string({
 			required: true,
-		},
-		{
-			name: 'type',
+		}),
+		type: Args.string({
 			required: true,
-		},
-		{
-			name: 'config',
+		}),
+		config: Args.string({
 			required: true,
-		},
-	];
+		}),
+	};
 
 	public static usage = (
 		'internal osinit ' +
@@ -66,7 +58,7 @@ export default class OsinitCmd extends Command {
 	public static offlineCompatible = true;
 
 	public async run() {
-		const { args: params } = this.parse<{}, ArgsDef>(OsinitCmd);
+		const { args: params } = await this.parse(OsinitCmd);
 
 		const config = JSON.parse(params.config);
 

lib/commands/join/index.ts

@@ -15,22 +15,12 @@
  * limitations under the License.
  */
 
-import { flags } from '@oclif/command';
-import Command from '../command';
-import * as cf from '../utils/common-flags';
-import { getBalenaSdk, stripIndent } from '../utils/lazy';
-import { applicationIdInfo } from '../utils/messages';
-import { parseAsLocalHostnameOrIp } from '../utils/validation';
-
-interface FlagsDef {
-	fleet?: string;
-	pollInterval?: number;
-	help?: void;
-}
-
-interface ArgsDef {
-	deviceIpOrHostname?: string;
-}
+import { Args, Flags } from '@oclif/core';
+import Command from '../../command';
+import * as cf from '../../utils/common-flags';
+import { getBalenaSdk, stripIndent } from '../../utils/lazy';
+import { applicationIdInfo } from '../../utils/messages';
+import { parseAsLocalHostnameOrIp } from '../../utils/validation';
 
 export default class JoinCmd extends Command {
 	public static description = stripIndent`
@@ -63,20 +53,19 @@ export default class JoinCmd extends Command {
 		'$ balena join 192.168.1.25 --fleet MyFleet',
 	];
 
-	public static args = [
-		{
-			name: 'deviceIpOrHostname',
+	public static args = {
+		deviceIpOrHostname: Args.string({
 			description: 'the IP or hostname of device',
 			parse: parseAsLocalHostnameOrIp,
-		},
-	];
+		}),
+	};
 
 	// Hardcoded to preserve camelcase
 	public static usage = 'join [deviceIpOrHostname]';
 
-	public static flags: flags.Input<FlagsDef> = {
+	public static flags = {
 		fleet: cf.fleet,
-		pollInterval: flags.integer({
+		pollInterval: Flags.integer({
 			description: 'the interval in minutes to check for updates',
 			char: 'i',
 		}),
@@ -87,11 +76,9 @@ export default class JoinCmd extends Command {
 	public static primary = true;
 
 	public async run() {
-		const { args: params, flags: options } = this.parse<FlagsDef, ArgsDef>(
-			JoinCmd,
-		);
+		const { args: params, flags: options } = await this.parse(JoinCmd);
 
-		const promote = await import('../utils/promote');
+		const promote = await import('../../utils/promote');
 		const sdk = getBalenaSdk();
 		const logger = await Command.getLogger();
 		return promote.join(

lib/commands/key/add.ts

@@ -15,21 +15,12 @@
  * limitations under the License.
  */
 
-import { flags } from '@oclif/command';
+import { Args } from '@oclif/core';
 import Command from '../../command';
 import { ExpectedError } from '../../errors';
 import * as cf from '../../utils/common-flags';
 import { getBalenaSdk, stripIndent } from '../../utils/lazy';
 
-interface FlagsDef {
-	help: void;
-}
-
-interface ArgsDef {
-	name: string;
-	path: string;
-}
-
 export default class KeyAddCmd extends Command {
 	public static description = stripIndent`
 		Add an SSH key to balenaCloud.
@@ -60,21 +51,19 @@ export default class KeyAddCmd extends Command {
 		'$ balena key add Main %userprofile%.sshid_rsa.pub',
 	];
 
-	public static args = [
-		{
-			name: 'name',
+	public static args = {
+		name: Args.string({
 			description: 'the SSH key name',
 			required: true,
-		},
-		{
-			name: `path`,
+		}),
+		path: Args.string({
 			description: `the path to the public key file`,
-		},
-	];
+		}),
+	};
 
 	public static usage = 'key add <name> [path]';
 
-	public static flags: flags.Input<FlagsDef> = {
+	public static flags = {
 		help: cf.help,
 	};
 
@@ -83,7 +72,7 @@ export default class KeyAddCmd extends Command {
 	public static readStdin = true;
 
 	public async run() {
-		const { args: params } = this.parse<FlagsDef, ArgsDef>(KeyAddCmd);
+		const { args: params } = await this.parse(KeyAddCmd);
 
 		let key: string;
 		if (params.path != null) {

lib/commands/key/index.ts

@@ -15,22 +15,12 @@
  * limitations under the License.
  */
 
-import { flags } from '@oclif/command';
+import { Args } from '@oclif/core';
 import Command from '../../command';
 import * as cf from '../../utils/common-flags';
 import { getBalenaSdk, getVisuals, stripIndent } from '../../utils/lazy';
 import { parseAsInteger } from '../../utils/validation';
 
-type IArg<T> = import('@oclif/parser').args.IArg<T>;
-
-interface FlagsDef {
-	help: void;
-}
-
-interface ArgsDef {
-	id: number;
-}
-
 export default class KeyCmd extends Command {
 	public static description = stripIndent`
 		Display an SSH key.
@@ -40,25 +30,24 @@ export default class KeyCmd extends Command {
 
 	public static examples = ['$ balena key 17'];
 
-	public static args: Array<IArg<any>> = [
-		{
-			name: 'id',
+	public static args = {
+		id: Args.integer({
 			description: 'balenaCloud ID for the SSH key',
-			parse: (x) => parseAsInteger(x, 'id'),
+			parse: async (x) => parseAsInteger(x, 'id'),
 			required: true,
-		},
-	];
+		}),
+	};
 
 	public static usage = 'key <id>';
 
-	public static flags: flags.Input<FlagsDef> = {
+	public static flags = {
 		help: cf.help,
 	};
 
 	public static authenticated = true;
 
 	public async run() {
-		const { args: params } = this.parse<{}, ArgsDef>(KeyCmd);
+		const { args: params } = await this.parse(KeyCmd);
 
 		const key = await getBalenaSdk().models.key.get(params.id);
 

lib/commands/key/rm.ts

@@ -15,23 +15,12 @@
  * limitations under the License.
  */
 
-import { flags } from '@oclif/command';
+import { Args } from '@oclif/core';
 import Command from '../../command';
 import * as cf from '../../utils/common-flags';
 import { getBalenaSdk, stripIndent } from '../../utils/lazy';
 import { parseAsInteger } from '../../utils/validation';
 
-type IArg<T> = import('@oclif/parser').args.IArg<T>;
-
-interface FlagsDef {
-	yes: boolean;
-	help: void;
-}
-
-interface ArgsDef {
-	id: number;
-}
-
 export default class KeyRmCmd extends Command {
 	public static description = stripIndent`
 		Remove an SSH key from balenaCloud.
@@ -43,18 +32,17 @@ export default class KeyRmCmd extends Command {
 
 	public static examples = ['$ balena key rm 17', '$ balena key rm 17 --yes'];
 
-	public static args: Array<IArg<any>> = [
-		{
-			name: 'id',
+	public static args = {
+		id: Args.integer({
 			description: 'balenaCloud ID for the SSH key',
-			parse: (x) => parseAsInteger(x, 'id'),
+			parse: async (x) => parseAsInteger(x, 'id'),
 			required: true,
-		},
-	];
+		}),
+	};
 
 	public static usage = 'key rm <id>';
 
-	public static flags: flags.Input<FlagsDef> = {
+	public static flags = {
 		yes: cf.yes,
 		help: cf.help,
 	};
@@ -62,9 +50,7 @@ export default class KeyRmCmd extends Command {
 	public static authenticated = true;
 
 	public async run() {
-		const { args: params, flags: options } = this.parse<FlagsDef, ArgsDef>(
-			KeyRmCmd,
-		);
+		const { args: params, flags: options } = await this.parse(KeyRmCmd);
 
 		const patterns = await import('../../utils/patterns');
 

lib/commands/keys/index.ts

@@ -15,14 +15,9 @@
  * limitations under the License.
  */
 
-import { flags } from '@oclif/command';
-import Command from '../command';
-import * as cf from '../utils/common-flags';
-import { getBalenaSdk, getVisuals, stripIndent } from '../utils/lazy';
-
-interface FlagsDef {
-	help: void;
-}
+import Command from '../../command';
+import * as cf from '../../utils/common-flags';
+import { getBalenaSdk, getVisuals, stripIndent } from '../../utils/lazy';
 
 export default class KeysCmd extends Command {
 	public static description = stripIndent`
@@ -34,14 +29,14 @@ export default class KeysCmd extends Command {
 
 	public static usage = 'keys';
 
-	public static flags: flags.Input<FlagsDef> = {
+	public static flags = {
 		help: cf.help,
 	};
 
 	public static authenticated = true;
 
 	public async run() {
-		this.parse<FlagsDef, {}>(KeysCmd);
+		await this.parse(KeysCmd);
 
 		const keys = await getBalenaSdk().models.key.getAll();
 

lib/commands/leave/index.ts

@@ -15,19 +15,11 @@
  * limitations under the License.
  */
 
-import { flags } from '@oclif/command';
-import Command from '../command';
-import * as cf from '../utils/common-flags';
-import { stripIndent } from '../utils/lazy';
-import { parseAsLocalHostnameOrIp } from '../utils/validation';
-
-interface FlagsDef {
-	help?: void;
-}
-
-interface ArgsDef {
-	deviceIpOrHostname?: string;
-}
+import { Args } from '@oclif/core';
+import Command from '../../command';
+import * as cf from '../../utils/common-flags';
+import { stripIndent } from '../../utils/lazy';
+import { parseAsLocalHostnameOrIp } from '../../utils/validation';
 
 export default class LeaveCmd extends Command {
 	public static description = stripIndent`
@@ -51,17 +43,16 @@ export default class LeaveCmd extends Command {
 		'$ balena leave 192.168.1.25',
 	];
 
-	public static args = [
-		{
-			name: 'deviceIpOrHostname',
+	public static args = {
+		deviceIpOrHostname: Args.string({
 			description: 'the device IP or hostname',
 			parse: parseAsLocalHostnameOrIp,
-		},
-	];
+		}),
+	};
 
 	public static usage = 'leave [deviceIpOrHostname]';
 
-	public static flags: flags.Input<FlagsDef> = {
+	public static flags = {
 		help: cf.help,
 	};
 
@@ -69,9 +60,9 @@ export default class LeaveCmd extends Command {
 	public static primary = true;
 
 	public async run() {
-		const { args: params } = this.parse<FlagsDef, ArgsDef>(LeaveCmd);
+		const { args: params } = await this.parse(LeaveCmd);
 
-		const promote = await import('../utils/promote');
+		const promote = await import('../../utils/promote');
 		const logger = await Command.getLogger();
 		return promote.leave(logger, params.deviceIpOrHostname);
 	}

lib/commands/local/configure.ts

@@ -15,20 +15,12 @@
  * limitations under the License.
  */
 
-import { flags } from '@oclif/command';
+import { Args } from '@oclif/core';
 import { promisify } from 'util';
 import Command from '../../command';
 import * as cf from '../../utils/common-flags';
 import { stripIndent } from '../../utils/lazy';
 
-interface FlagsDef {
-	help: void;
-}
-
-interface ArgsDef {
-	target: string;
-}
-
 export default class LocalConfigureCmd extends Command {
 	public static description = stripIndent`
 		(Re)configure a balenaOS drive or image.
@@ -41,17 +33,16 @@ export default class LocalConfigureCmd extends Command {
 		'$ balena local configure path/to/image.img',
 	];
 
-	public static args = [
-		{
-			name: 'target',
+	public static args = {
+		target: Args.string({
 			description: 'path of drive or image to configure',
 			required: true,
-		},
-	];
+		}),
+	};
 
 	public static usage = 'local configure <target>';
 
-	public static flags: flags.Input<FlagsDef> = {
+	public static flags = {
 		help: cf.help,
 	};
 
@@ -59,7 +50,7 @@ export default class LocalConfigureCmd extends Command {
 	public static offlineCompatible = true;
 
 	public async run() {
-		const { args: params } = this.parse<FlagsDef, ArgsDef>(LocalConfigureCmd);
+		const { args: params } = await this.parse(LocalConfigureCmd);
 
 		const reconfix = await import('reconfix');
 		const { denyMount, safeUmount } = await import('../../utils/umount');

lib/commands/local/flash.ts

@@ -15,23 +15,13 @@
  * limitations under the License.
  */
 
-import { flags } from '@oclif/command';
+import { Args } from '@oclif/core';
 import type { BlockDevice } from 'etcher-sdk/build/source-destination';
 import Command from '../../command';
 import { ExpectedError } from '../../errors';
 import * as cf from '../../utils/common-flags';
 import { getChalk, getVisuals, stripIndent } from '../../utils/lazy';
 
-interface FlagsDef {
-	yes: boolean;
-	drive?: string;
-	help: void;
-}
-
-interface ArgsDef {
-	image: string;
-}
-
 export default class LocalFlashCmd extends Command {
 	public static description = stripIndent`
 		Flash an image to a drive.
@@ -49,17 +39,16 @@ export default class LocalFlashCmd extends Command {
 		'$ balena local flash path/to/balenaos.img --drive /dev/disk2 --yes',
 	];
 
-	public static args = [
-		{
-			name: 'image',
+	public static args = {
+		image: Args.string({
 			description: 'path to OS image',
 			required: true,
-		},
-	];
+		}),
+	};
 
 	public static usage = 'local flash <image>';
 
-	public static flags: flags.Input<FlagsDef> = {
+	public static flags = {
 		drive: cf.drive,
 		yes: cf.yes,
 		help: cf.help,
@@ -68,9 +57,7 @@ export default class LocalFlashCmd extends Command {
 	public static offlineCompatible = true;
 
 	public async run() {
-		const { args: params, flags: options } = this.parse<FlagsDef, ArgsDef>(
-			LocalFlashCmd,
-		);
+		const { args: params, flags: options } = await this.parse(LocalFlashCmd);
 
 		if (process.platform === 'linux') {
 			const { promisify } = await import('util');

lib/commands/login/index.ts

@@ -15,11 +15,12 @@
  * limitations under the License.
  */
 
-import { flags } from '@oclif/command';
-import Command from '../command';
-import * as cf from '../utils/common-flags';
-import { getBalenaSdk, stripIndent, getCliForm } from '../utils/lazy';
-import { ExpectedError } from '../errors';
+import { Flags, Args } from '@oclif/core';
+import Command from '../../command';
+import * as cf from '../../utils/common-flags';
+import { getBalenaSdk, stripIndent, getCliForm } from '../../utils/lazy';
+import { ExpectedError } from '../../errors';
+import type { WhoamiResult } from 'balena-sdk';
 
 interface FlagsDef {
 	token: boolean;
@@ -30,10 +31,7 @@ interface FlagsDef {
 	password?: string;
 	port?: number;
 	help: void;
-}
-
-interface ArgsDef {
-	token?: string;
+	hideExperimentalWarning: boolean;
 }
 
 export default class LoginCmd extends Command {
@@ -59,37 +57,34 @@ export default class LoginCmd extends Command {
 		'$ balena login --credentials --email johndoe@gmail.com --password secret',
 	];
 
-	public static args = [
-		{
-			// Capitano allowed -t to be type boolean|string, which oclif does not.
-			// So -t is now bool, and we check first arg for token content.
-			name: 'token',
+	public static args = {
+		token: Args.string({
 			hidden: true,
-		},
-	];
+		}),
+	};
 
 	public static usage = 'login';
 
-	public static flags: flags.Input<FlagsDef> = {
-		web: flags.boolean({
+	public static flags = {
+		web: Flags.boolean({
 			default: false,
 			char: 'w',
 			description: 'web-based login',
 			exclusive: ['token', 'credentials'],
 		}),
-		token: flags.boolean({
+		token: Flags.boolean({
 			default: false,
 			char: 't',
 			description: 'session token or API key',
 			exclusive: ['web', 'credentials'],
 		}),
-		credentials: flags.boolean({
+		credentials: Flags.boolean({
 			default: false,
 			char: 'c',
 			description: 'credential-based login',
 			exclusive: ['web', 'token'],
 		}),
-		email: flags.string({
+		email: Flags.string({
 			char: 'e',
 			description: 'email',
 			exclusive: ['user'],
@@ -97,35 +92,38 @@ export default class LoginCmd extends Command {
 		}),
 		// Capitano version of this command had a second alias for email, 'u'.
 		// Using an oclif hidden flag to support the same behaviour.
-		user: flags.string({
+		user: Flags.string({
 			char: 'u',
 			hidden: true,
 			exclusive: ['email'],
 			dependsOn: ['credentials'],
 		}),
-		password: flags.string({
+		password: Flags.string({
 			char: 'p',
 			description: 'password',
 			dependsOn: ['credentials'],
 		}),
-		port: flags.integer({
+		port: Flags.integer({
 			char: 'P',
 			description:
 				'TCP port number of local HTTP login server (--web auth only)',
 			dependsOn: ['web'],
 		}),
+		hideExperimentalWarning: Flags.boolean({
+			char: 'H',
+			default: false,
+			description: 'Hides warning for experimental features',
+		}),
 		help: cf.help,
 	};
 
 	public static primary = true;
 
 	public async run() {
-		const { flags: options, args: params } = this.parse<FlagsDef, ArgsDef>(
-			LoginCmd,
-		);
+		const { flags: options, args: params } = await this.parse(LoginCmd);
 
 		const balena = getBalenaSdk();
-		const messages = await import('../utils/messages');
+		const messages = await import('../../utils/messages');
 		const balenaUrl = await balena.settings.get('balenaUrl');
 
 		// Consolidate user/email options
@@ -137,9 +135,24 @@ export default class LoginCmd extends Command {
 		console.log(`\nLogging in to ${balenaUrl}`);
 		await this.doLogin(options, balenaUrl, params.token);
 
-		const username = await balena.auth.whoami();
+		// We can safely assume this won't be undefined as doLogin will throw if this call fails
+		// We also don't need to worry too much about the amount of calls to whoami
+		// as these are cached by the SDK
+		const whoamiResult = (await balena.auth.whoami()) as WhoamiResult;
 
-		console.info(`Successfully logged in as: ${username}`);
+		if (whoamiResult.actorType !== 'user' && !options.hideExperimentalWarning) {
+			console.info(stripIndent`
+			----------------------------------------------------------------------------------------
+			You are logging in with a ${whoamiResult.actorType} key.
+			This is an experimental feature and many features of the CLI might not work as expected.
+			We sure hope you know what you are doing.
+			----------------------------------------------------------------------------------------
+			`);
+		}
+
+		console.info(
+			`Successfully logged in as: ${this.getLoggedInMessage(whoamiResult)}`,
+		);
 		console.info(`\
 
 Find out about the available commands by running:
@@ -149,6 +162,16 @@ Find out about the available commands by running:
 ${messages.reachingOut}`);
 	}
 
+	private getLoggedInMessage(whoami: WhoamiResult): string {
+		if (whoami.actorType === 'user') {
+			return whoami.username;
+		}
+
+		const identifier =
+			whoami.actorType === 'device' ? whoami.uuid : whoami.slug;
+		return `${whoami.actorType} ${identifier}`;
+	}
+
 	async doLogin(
 		loginOptions: FlagsDef,
 		balenaUrl: string = 'balena-cloud.com',
@@ -165,23 +188,30 @@ ${messages.reachingOut}`);
 			}
 			const balena = getBalenaSdk();
 			await balena.auth.loginWithToken(token!);
-			if (!(await balena.auth.whoami())) {
+			try {
+				if (!(await balena.auth.whoami())) {
+					throw new ExpectedError('Token authentication failed');
+				}
+			} catch (err) {
+				if (process.env.DEBUG) {
+					console.error(`Get user info failed with: ${err.message}`);
+				}
 				throw new ExpectedError('Token authentication failed');
 			}
 			return;
 		}
 		// Credentials
 		else if (loginOptions.credentials) {
-			const patterns = await import('../utils/patterns');
+			const patterns = await import('../../utils/patterns');
 			return patterns.authenticate(loginOptions);
 		}
 		// Web
 		else if (loginOptions.web) {
-			const auth = await import('../auth');
+			const auth = await import('../../auth');
 			await auth.login({ port: loginOptions.port });
 			return;
 		} else {
-			const patterns = await import('../utils/patterns');
+			const patterns = await import('../../utils/patterns');
 			// User had not selected login preference, prompt interactively
 			const loginType = await patterns.askLoginType();
 			if (loginType === 'register') {

lib/commands/logout/index.ts

@@ -15,8 +15,8 @@
  * limitations under the License.
  */
 
-import Command from '../command';
-import { getBalenaSdk, stripIndent } from '../utils/lazy';
+import Command from '../../command';
+import { getBalenaSdk, stripIndent } from '../../utils/lazy';
 
 export default class LogoutCmd extends Command {
 	public static description = stripIndent`
@@ -29,7 +29,7 @@ export default class LogoutCmd extends Command {
 	public static usage = 'logout';
 
 	public async run() {
-		this.parse<{}, {}>(LogoutCmd);
+		await this.parse(LogoutCmd);
 		await getBalenaSdk().auth.logout();
 	}
 }

lib/commands/logs/index.ts

@@ -15,24 +15,11 @@
  * limitations under the License.
  */
 
-import { flags } from '@oclif/command';
-import Command from '../command';
-import * as cf from '../utils/common-flags';
-import { getBalenaSdk, stripIndent } from '../utils/lazy';
+import { Flags, Args } from '@oclif/core';
+import Command from '../../command';
+import * as cf from '../../utils/common-flags';
+import { getBalenaSdk, stripIndent } from '../../utils/lazy';
 import { LogMessage } from 'balena-sdk';
-import { IArg } from '@oclif/parser/lib/args';
-
-interface FlagsDef {
-	'max-retry'?: number;
-	tail?: boolean;
-	service?: string[];
-	system?: boolean;
-	help: void;
-}
-
-interface ArgsDef {
-	device: string;
-}
 
 const MAX_RETRY = 1000;
 
@@ -67,35 +54,34 @@ export default class LogsCmd extends Command {
 		'$ balena logs 23c73a1.local --system --service my-service',
 	];
 
-	public static args: Array<IArg<any>> = [
-		{
-			name: 'device',
+	public static args = {
+		device: Args.string({
 			description: 'device UUID, IP, or .local address',
 			required: true,
-		},
-	];
+		}),
+	};
 
 	public static usage = 'logs <device>';
 
-	public static flags: flags.Input<FlagsDef> = {
-		'max-retry': flags.integer({
+	public static flags = {
+		'max-retry': Flags.integer({
 			description: stripIndent`
 				Maximum number of reconnection attempts on "connection lost" errors
 				(use 0 to disable auto reconnection).`,
 		}),
-		tail: flags.boolean({
+		tail: Flags.boolean({
 			default: false,
 			description: 'continuously stream output',
 			char: 't',
 		}),
-		service: flags.string({
+		service: Flags.string({
 			description: stripIndent`
 				Reject logs not originating from this service.
 				This can be used in combination with --system or other --service flags.`,
 			char: 's',
 			multiple: true,
 		}),
-		system: flags.boolean({
+		system: Flags.boolean({
 			default: false,
 			description:
 				'Only show system logs. This can be used in combination with --service.',
@@ -107,19 +93,17 @@ export default class LogsCmd extends Command {
 	public static primary = true;
 
 	public async run() {
-		const { args: params, flags: options } = this.parse<FlagsDef, ArgsDef>(
-			LogsCmd,
-		);
+		const { args: params, flags: options } = await this.parse(LogsCmd);
 
 		const balena = getBalenaSdk();
-		const { serviceIdToName } = await import('../utils/cloud');
+		const { serviceIdToName } = await import('../../utils/cloud');
 		const { connectAndDisplayDeviceLogs, displayLogObject } = await import(
-			'../utils/device/logs'
+			'../../utils/device/logs'
 		);
 		const { validateIPAddress, validateDotLocalUrl } = await import(
-			'../utils/validation'
+			'../../utils/validation'
 		);
-		const Logger = await import('../utils/logger');
+		const Logger = await import('../../utils/logger');
 
 		const logger = Logger.getLogger();
 
@@ -148,13 +132,13 @@ export default class LogsCmd extends Command {
 			validateDotLocalUrl(params.device)
 		) {
 			// Logs from local device
-			const { DeviceAPI } = await import('../utils/device/api');
+			const { DeviceAPI } = await import('../../utils/device/api');
 			const deviceApi = new DeviceAPI(logger, params.device);
 			logger.logDebug('Checking we can access device');
 			try {
 				await deviceApi.ping();
 			} catch (e) {
-				const { ExpectedError } = await import('../errors');
+				const { ExpectedError } = await import('../../errors');
 				throw new ExpectedError(
 					`Cannot access device at address ${params.device}.  Device may not be in local mode.`,
 				);

lib/commands/notes/index.ts

@@ -15,21 +15,11 @@
  * limitations under the License.
  */
 
-import { flags } from '@oclif/command';
-import Command from '../command';
-import { ExpectedError } from '../errors';
-import * as cf from '../utils/common-flags';
-import { getBalenaSdk, stripIndent } from '../utils/lazy';
-
-interface FlagsDef {
-	device?: string; // device UUID
-	dev?: string; // Alias for device.
-	help: void;
-}
-
-interface ArgsDef {
-	note: string;
-}
+import { Flags, Args } from '@oclif/core';
+import Command from '../../command';
+import { ExpectedError } from '../../errors';
+import * as cf from '../../utils/common-flags';
+import { getBalenaSdk, stripIndent } from '../../utils/lazy';
 
 export default class NoteCmd extends Command {
 	public static description = stripIndent`
@@ -46,18 +36,17 @@ export default class NoteCmd extends Command {
 		'$ cat note.txt | balena note --device 7cf02a6',
 	];
 
-	public static args = [
-		{
-			name: 'note',
+	public static args = {
+		note: Args.string({
 			description: 'note content',
-		},
-	];
+		}),
+	};
 
 	public static usage = 'note <|note>';
 
-	public static flags: flags.Input<FlagsDef> = {
+	public static flags = {
 		device: { exclusive: ['dev'], ...cf.device },
-		dev: flags.string({
+		dev: Flags.string({
 			exclusive: ['device'],
 			hidden: true,
 		}),
@@ -69,9 +58,7 @@ export default class NoteCmd extends Command {
 	public static readStdin = true;
 
 	public async run() {
-		const { args: params, flags: options } = this.parse<FlagsDef, ArgsDef>(
-			NoteCmd,
-		);
+		const { args: params, flags: options } = await this.parse(NoteCmd);
 
 		params.note = params.note || this.stdin;
 
@@ -88,6 +75,6 @@ export default class NoteCmd extends Command {
 
 		const balena = getBalenaSdk();
 
-		return balena.models.device.note(options.device!, params.note);
+		return balena.models.device.setNote(options.device, params.note);
 	}
 }

lib/commands/orgs/index.ts

@@ -15,14 +15,9 @@
  * limitations under the License.
  */
 
-import { flags } from '@oclif/command';
-import Command from '../command';
-import * as cf from '../utils/common-flags';
-import { getBalenaSdk, getVisuals, stripIndent } from '../utils/lazy';
-
-interface FlagsDef {
-	help: void;
-}
+import Command from '../../command';
+import * as cf from '../../utils/common-flags';
+import { getBalenaSdk, getVisuals, stripIndent } from '../../utils/lazy';
 
 export default class OrgsCmd extends Command {
 	public static description = stripIndent`
@@ -34,19 +29,21 @@ export default class OrgsCmd extends Command {
 
 	public static usage = 'orgs';
 
-	public static flags: flags.Input<FlagsDef> = {
+	public static flags = {
 		help: cf.help,
 	};
 
 	public static authenticated = true;
 
 	public async run() {
-		this.parse<FlagsDef, {}>(OrgsCmd);
+		await this.parse(OrgsCmd);
 
-		const { getOwnOrganizations } = await import('../utils/sdk');
+		const { getOwnOrganizations } = await import('../../utils/sdk');
 
 		// Get organizations
-		const organizations = await getOwnOrganizations(getBalenaSdk());
+		const organizations = await getOwnOrganizations(getBalenaSdk(), {
+			$select: ['name', 'handle'],
+		});
 
 		// Display
 		console.log(

lib/commands/os/build-config.ts

@@ -15,24 +15,13 @@
  * limitations under the License.
  */
 
-import { flags } from '@oclif/command';
+import { Flags, Args } from '@oclif/core';
 import Command from '../../command';
 import * as cf from '../../utils/common-flags';
 import { getCliForm, stripIndent } from '../../utils/lazy';
 import * as _ from 'lodash';
 import type { DeviceTypeJson } from 'balena-sdk';
 
-interface FlagsDef {
-	advanced: boolean;
-	output: string;
-	help: void;
-}
-
-interface ArgsDef {
-	image: string;
-	'device-type': string;
-}
-
 export default class OsBuildConfigCmd extends Command {
 	public static description = stripIndent`
 		Prepare a configuration file for use by the 'os configure' command.
@@ -46,27 +35,25 @@ export default class OsBuildConfigCmd extends Command {
 		'$ balena os configure ../path/rpi3.img --device 7cf02a6 --config rpi3-config.json',
 	];
 
-	public static args = [
-		{
-			name: 'image',
+	public static args = {
+		image: Args.string({
 			description: 'os image',
 			required: true,
-		},
-		{
-			name: 'device-type',
+		}),
+		'device-type': Args.string({
 			description: 'device type',
 			required: true,
-		},
-	];
+		}),
+	};
 
 	public static usage = 'os build-config <image> <device-type>';
 
-	public static flags: flags.Input<FlagsDef> = {
-		advanced: flags.boolean({
+	public static flags = {
+		advanced: Flags.boolean({
 			description: 'show advanced configuration options',
 			char: 'v',
 		}),
-		output: flags.string({
+		output: Flags.string({
 			description: 'path to output JSON file',
 			char: 'o',
 			required: true,
@@ -77,9 +64,7 @@ export default class OsBuildConfigCmd extends Command {
 	public static authenticated = true;
 
 	public async run() {
-		const { args: params, flags: options } = this.parse<FlagsDef, ArgsDef>(
-			OsBuildConfigCmd,
-		);
+		const { args: params, flags: options } = await this.parse(OsBuildConfigCmd);
 
 		const { writeFile } = (await import('fs')).promises;
 

lib/commands/os/configure.ts

@@ -15,7 +15,8 @@
  * limitations under the License.
  */
 
-import { flags } from '@oclif/command';
+import { Flags, Args } from '@oclif/core';
+import type { Interfaces } from '@oclif/core';
 import type * as BalenaSdk from 'balena-sdk';
 import { promisify } from 'util';
 import * as _ from 'lodash';
@@ -23,41 +24,27 @@ import Command from '../../command';
 import { ExpectedError } from '../../errors';
 import * as cf from '../../utils/common-flags';
 import { getBalenaSdk, stripIndent, getCliForm } from '../../utils/lazy';
-import { applicationIdInfo, devModeInfo } from '../../utils/messages';
+import {
+	applicationIdInfo,
+	devModeInfo,
+	secureBootInfo,
+} from '../../utils/messages';
 
 const CONNECTIONS_FOLDER = '/system-connections';
 
-interface FlagsDef {
-	advanced?: boolean;
-	fleet?: string;
-	config?: string;
-	'config-app-update-poll-interval'?: number;
-	'config-network'?: string;
-	'config-wifi-key'?: string;
-	'config-wifi-ssid'?: string;
-	dev?: boolean; // balenaOS development variant
-	device?: string; // device UUID
-	'device-type'?: string;
-	help?: void;
-	version?: string;
-	'system-connection': string[];
-	'initial-device-name'?: string;
-	'provisioning-key-name'?: string;
-}
-
-interface ArgsDef {
-	image: string;
-}
+type FlagsDef = Interfaces.InferredFlags<typeof OsConfigureCmd.flags>;
 
 interface Answers {
 	appUpdatePollInterval: number; // in minutes
 	developmentMode?: boolean; // balenaOS development variant
+	secureBoot?: boolean;
 	deviceType: string; // e.g. "raspberrypi3"
 	network: 'ethernet' | 'wifi';
 	version: string; // e.g. "2.32.0+rev1"
 	wifiSsid?: string;
 	wifiKey?: string;
 	provisioningKeyName?: string;
+	provisioningKeyExpiryDate?: string;
 }
 
 export default class OsConfigureCmd extends Command {
@@ -78,6 +65,8 @@ export default class OsConfigureCmd extends Command {
 
 		${devModeInfo.split('\n').join('\n\t\t')}
 
+		${secureBootInfo.split('\n').join('\n\t\t')}
+
 		The --system-connection (-c) option is used to inject NetworkManager connection
 		profiles for additional network interfaces, such as cellular/GSM or additional
 		WiFi or ethernet connections. This option may be passed multiple times in case there
@@ -101,75 +90,85 @@ export default class OsConfigureCmd extends Command {
 		'$ balena os configure ../path/rpi3.img -f MyFinFleet --device-type raspberrypi3 --config myWifiConfig.json',
 	];
 
-	public static args = [
-		{
-			name: 'image',
+	public static args = {
+		image: Args.string({
 			required: true,
 			description: 'path to a balenaOS image file, e.g. "rpi3.img"',
-		},
-	];
+		}),
+	};
 
 	public static usage = 'os configure <image>';
 
-	public static flags: flags.Input<FlagsDef> = {
-		advanced: flags.boolean({
+	public static flags = {
+		advanced: Flags.boolean({
 			char: 'v',
 			description:
 				'ask advanced configuration questions (when in interactive mode)',
 		}),
 		fleet: { ...cf.fleet, exclusive: ['device'] },
-		config: flags.string({
+		config: Flags.string({
 			description:
 				'path to a pre-generated config.json file to be injected in the OS image',
-			exclusive: ['provisioning-key-name'],
+			exclusive: ['provisioning-key-name', 'provisioning-key-expiry-date'],
 		}),
-		'config-app-update-poll-interval': flags.integer({
+		'config-app-update-poll-interval': Flags.integer({
 			description:
 				'supervisor cloud polling interval in minutes (e.g. for variable updates)',
 		}),
-		'config-network': flags.string({
+		'config-network': Flags.string({
 			description: 'device network type (non-interactive configuration)',
 			options: ['ethernet', 'wifi'],
 		}),
-		'config-wifi-key': flags.string({
+		'config-wifi-key': Flags.string({
 			description: 'WiFi key (password) (non-interactive configuration)',
 		}),
-		'config-wifi-ssid': flags.string({
+		'config-wifi-ssid': Flags.string({
 			description: 'WiFi SSID (network name) (non-interactive configuration)',
 		}),
 		dev: cf.dev,
-		device: { ...cf.device, exclusive: ['fleet', 'provisioning-key-name'] },
-		'device-type': flags.string({
+		secureBoot: cf.secureBoot,
+		device: {
+			...cf.device,
+			exclusive: [
+				'fleet',
+				'provisioning-key-name',
+				'provisioning-key-expiry-date',
+			],
+		},
+		'device-type': Flags.string({
 			description:
 				'device type slug (e.g. "raspberrypi3") to override the fleet device type',
 		}),
-		'initial-device-name': flags.string({
+		'initial-device-name': Flags.string({
 			description:
 				'This option will set the device name when the device provisions',
 		}),
-		version: flags.string({
+		version: Flags.string({
 			description: 'balenaOS version, for example "2.32.0" or "2.44.0+rev1"',
 		}),
-		'system-connection': flags.string({
+		'system-connection': Flags.string({
 			multiple: true,
 			char: 'c',
 			required: false,
 			description:
 				"paths to local files to place into the 'system-connections' directory",
 		}),
-		'provisioning-key-name': flags.string({
+		'provisioning-key-name': Flags.string({
 			description: 'custom key name assigned to generated provisioning api key',
 			exclusive: ['config', 'device'],
 		}),
+		'provisioning-key-expiry-date': Flags.string({
+			description:
+				'expiry date assigned to generated provisioning api key (format: YYYY-MM-DD)',
+			exclusive: ['config', 'device'],
+		}),
 		help: cf.help,
 	};
 
 	public static authenticated = true;
 
 	public async run() {
-		const { args: params, flags: options } = this.parse<FlagsDef, ArgsDef>(
-			OsConfigureCmd,
-		);
+		const { args: params, flags: options } = await this.parse(OsConfigureCmd);
 
 		await validateOptions(options);
 
@@ -181,7 +180,7 @@ export default class OsConfigureCmd extends Command {
 		const helpers = await import('../../utils/helpers');
 		const { getApplication } = await import('../../utils/sdk');
 
-		let app: ApplicationWithDeviceType | undefined;
+		let app: ApplicationWithDeviceTypeSlug | undefined;
 		let device;
 		let deviceTypeSlug: string;
 
@@ -200,8 +199,8 @@ export default class OsConfigureCmd extends Command {
 				$expand: {
 					is_for__device_type: { $select: 'slug' },
 				},
-			})) as ApplicationWithDeviceType;
-			await checkDeviceTypeCompatibility(balena, options, app);
+			})) as ApplicationWithDeviceTypeSlug;
+			await checkDeviceTypeCompatibility(options, app);
 			deviceTypeSlug =
 				options['device-type'] || app.is_for__device_type[0].slug;
 		}
@@ -217,13 +216,28 @@ export default class OsConfigureCmd extends Command {
 			configJson = JSON.parse(rawConfig);
 		}
 
-		const osVersion =
+		const { normalizeOsVersion } = await import('../../utils/normalization');
+		const osVersion = normalizeOsVersion(
 			options.version ||
-			(await getOsVersionFromImage(params.image, deviceTypeManifest, devInit));
+				(await getOsVersionFromImage(
+					params.image,
+					deviceTypeManifest,
+					devInit,
+				)),
+		);
 
 		const { validateDevOptionAndWarn } = await import('../../utils/config');
 		await validateDevOptionAndWarn(options.dev, osVersion);
 
+		const { validateSecureBootOptionAndWarn } = await import(
+			'../../utils/config'
+		);
+		await validateSecureBootOptionAndWarn(
+			options.secureBoot,
+			deviceTypeSlug,
+			osVersion,
+		);
+
 		const answers: Answers = await askQuestionsForDeviceType(
 			deviceTypeManifest,
 			options,
@@ -234,7 +248,9 @@ export default class OsConfigureCmd extends Command {
 		}
 		answers.version = osVersion;
 		answers.developmentMode = options.dev;
+		answers.secureBoot = options.secureBoot;
 		answers.provisioningKeyName = options['provisioning-key-name'];
+		answers.provisioningKeyExpiryDate = options['provisioning-key-expiry-date'];
 
 		if (_.isEmpty(configJson)) {
 			if (device) {
@@ -346,17 +362,19 @@ async function getOsVersionFromImage(
  * @param app Balena SDK Application model object
  */
 async function checkDeviceTypeCompatibility(
-	sdk: BalenaSdk.BalenaSDK,
 	options: FlagsDef,
-	app: ApplicationWithDeviceType,
+	app: {
+		is_for__device_type: [Pick<BalenaSdk.DeviceType, 'slug'>];
+	},
 ) {
 	if (options['device-type']) {
-		const [appDeviceType, optionDeviceType] = await Promise.all([
-			sdk.models.device.getManifestBySlug(app.is_for__device_type[0].slug),
-			sdk.models.device.getManifestBySlug(options['device-type']),
-		]);
 		const helpers = await import('../../utils/helpers');
-		if (!helpers.areDeviceTypesCompatible(appDeviceType, optionDeviceType)) {
+		if (
+			!(await helpers.areDeviceTypesCompatible(
+				app.is_for__device_type[0].slug,
+				options['device-type'],
+			))
+		) {
 			throw new ExpectedError(
 				`Device type ${options['device-type']} is incompatible with fleet ${options.fleet}`,
 			);

lib/commands/os/download.ts

@@ -15,21 +15,11 @@
  * limitations under the License.
  */
 
-import { flags } from '@oclif/command';
+import { Flags, Args } from '@oclif/core';
 import Command from '../../command';
 import * as cf from '../../utils/common-flags';
 import { stripIndent } from '../../utils/lazy';
 
-interface FlagsDef {
-	output: string;
-	version?: string;
-	help: void;
-}
-
-interface ArgsDef {
-	type: string;
-}
-
 export default class OsDownloadCmd extends Command {
 	public static description = stripIndent`
 		Download an unconfigured OS image.
@@ -53,9 +43,11 @@ export default class OsDownloadCmd extends Command {
 `;
 	public static examples = [
 		'$ balena os download raspberrypi3 -o ../foo/bar/raspberry-pi.img',
+		'$ balena os download raspberrypi3 -o ../foo/bar/raspberry-pi.img --version 2.101.7',
+		'$ balena os download raspberrypi3 -o ../foo/bar/raspberry-pi.img --version 2022.7.0',
+		'$ balena os download raspberrypi3 -o ../foo/bar/raspberry-pi.img --version ^2.90.0',
 		'$ balena os download raspberrypi3 -o ../foo/bar/raspberry-pi.img --version 2.60.1+rev1',
 		'$ balena os download raspberrypi3 -o ../foo/bar/raspberry-pi.img --version 2.60.1+rev1.dev',
-		'$ balena os download raspberrypi3 -o ../foo/bar/raspberry-pi.img --version ^2.60.0',
 		'$ balena os download raspberrypi3 -o ../foo/bar/raspberry-pi.img --version 2021.10.2.prod',
 		'$ balena os download raspberrypi3 -o ../foo/bar/raspberry-pi.img --version latest',
 		'$ balena os download raspberrypi3 -o ../foo/bar/raspberry-pi.img --version default',
@@ -63,23 +55,22 @@ export default class OsDownloadCmd extends Command {
 		'$ balena os download raspberrypi3 -o ../foo/bar/raspberry-pi.img --version menu-esr',
 	];
 
-	public static args = [
-		{
-			name: 'type',
+	public static args = {
+		type: Args.string({
 			description: 'the device type',
 			required: true,
-		},
-	];
+		}),
+	};
 
 	public static usage = 'os download <type>';
 
-	public static flags: flags.Input<FlagsDef> = {
-		output: flags.string({
+	public static flags = {
+		output: Flags.string({
 			description: 'output path',
 			char: 'o',
 			required: true,
 		}),
-		version: flags.string({
+		version: Flags.string({
 			description: stripIndent`
 				version number (ESR or non-ESR versions),
 				or semver range (non-ESR versions only),
@@ -94,9 +85,7 @@ export default class OsDownloadCmd extends Command {
 	};
 
 	public async run() {
-		const { args: params, flags: options } = this.parse<FlagsDef, ArgsDef>(
-			OsDownloadCmd,
-		);
+		const { args: params, flags: options } = await this.parse(OsDownloadCmd);
 
 		// balenaOS ESR versions require user authentication
 		if (options.version) {

lib/commands/os/initialize.ts

@@ -15,22 +15,11 @@
  * limitations under the License.
  */
 
-import { flags } from '@oclif/command';
+import { Args } from '@oclif/core';
 import Command from '../../command';
 import * as cf from '../../utils/common-flags';
 import { getCliForm, stripIndent } from '../../utils/lazy';
 
-interface FlagsDef {
-	type: string;
-	drive?: string;
-	yes: boolean;
-	help: void;
-}
-
-interface ArgsDef {
-	image: string;
-}
-
 const INIT_WARNING_MESSAGE = `
 
 Note: Initializing the device may ask for administrative permissions
@@ -42,7 +31,9 @@ export default class OsInitializeCmd extends Command {
 		Initialize an os image for a device.
 
 		Initialize an os image for a device with a previously
-		configured operating system image.
+		configured operating system image and flash the
+		an external storage drive or the device's storage
+		medium depending on the device type.
 		${INIT_WARNING_MESSAGE}
 	`;
 
@@ -50,17 +41,16 @@ export default class OsInitializeCmd extends Command {
 		'$ balena os initialize ../path/rpi.img --type raspberry-pi',
 	];
 
-	public static args = [
-		{
-			name: 'image',
+	public static args = {
+		image: Args.string({
 			description: 'path to OS image',
 			required: true,
-		},
-	];
+		}),
+	};
 
 	public static usage = 'os initialize <image>';
 
-	public static flags: flags.Input<FlagsDef> = {
+	public static flags = {
 		type: cf.deviceType,
 		drive: cf.drive,
 		yes: cf.yes,
@@ -70,9 +60,7 @@ export default class OsInitializeCmd extends Command {
 	public static authenticated = true;
 
 	public async run() {
-		const { args: params, flags: options } = this.parse<FlagsDef, ArgsDef>(
-			OsInitializeCmd,
-		);
+		const { args: params, flags: options } = await this.parse(OsInitializeCmd);
 
 		const { getManifest, sudo } = await import('../../utils/helpers');
 

lib/commands/os/versions.ts

@@ -15,20 +15,11 @@
  * limitations under the License.
  */
 
-import { flags } from '@oclif/command';
+import { Flags, Args } from '@oclif/core';
 import Command from '../../command';
 import * as cf from '../../utils/common-flags';
 import { stripIndent } from '../../utils/lazy';
 
-interface FlagsDef {
-	esr?: boolean;
-	help: void;
-}
-
-interface ArgsDef {
-	type: string;
-}
-
 export default class OsVersionsCmd extends Command {
 	public static description = stripIndent`
 		Show available balenaOS versions for the given device type.
@@ -42,33 +33,48 @@ export default class OsVersionsCmd extends Command {
 
 	public static examples = ['$ balena os versions raspberrypi3'];
 
-	public static args = [
-		{
-			name: 'type',
+	public static args = {
+		type: Args.string({
 			description: 'device type',
 			required: true,
-		},
-	];
+		}),
+	};
 
 	public static usage = 'os versions <type>';
 
-	public static flags: flags.Input<FlagsDef> = {
+	public static flags = {
 		help: cf.help,
-		esr: flags.boolean({
+		esr: Flags.boolean({
 			description: 'select balenaOS ESR versions',
 			default: false,
 		}),
+		'include-draft': Flags.boolean({
+			description: 'include pre-release balenaOS versions',
+			default: false,
+		}),
 	};
 
 	public async run() {
-		const { args: params, flags: options } = this.parse<FlagsDef, ArgsDef>(
-			OsVersionsCmd,
-		);
+		const { args: params, flags: options } = await this.parse(OsVersionsCmd);
+
+		if (options['include-draft']) {
+			const { warnify } = await import('../../utils/messages');
+			console.error(
+				warnify(stripIndent`
+				Using pre-release balenaOS versions is only supported for OS updates
+				and not for OS image downloads.
+			`),
+			);
+		}
 
 		const { formatOsVersion, getOsVersions } = await import(
 			'../../utils/cloud'
 		);
-		const vs = await getOsVersions(params.type, !!options.esr);
+		const vs = await getOsVersions(
+			params.type,
+			!!options.esr,
+			options['include-draft'],
+		);
 
 		console.log(vs.map((v) => formatOsVersion(v)).join('\n'));
 	}

lib/commands/preload/index.ts

@@ -15,40 +15,31 @@
  * limitations under the License.
  */
 
-import Command from '../command';
-import { ExpectedError } from '../errors';
-import * as cf from '../utils/common-flags';
+import Command from '../../command';
+import { ExpectedError } from '../../errors';
+import * as cf from '../../utils/common-flags';
 import {
 	getBalenaSdk,
 	getCliForm,
 	getVisuals,
 	stripIndent,
-} from '../utils/lazy';
-import { applicationIdInfo } from '../utils/messages';
-import type { DockerConnectionCliFlags } from '../utils/docker';
-import { dockerConnectionCliFlags } from '../utils/docker';
-import { parseAsInteger } from '../utils/validation';
+} from '../../utils/lazy';
+import { applicationIdInfo } from '../../utils/messages';
+import { dockerConnectionCliFlags } from '../../utils/docker';
+import { parseAsInteger } from '../../utils/validation';
 
-import { flags } from '@oclif/command';
+import { Flags, Args } from '@oclif/core';
 import * as _ from 'lodash';
-import type { Application, BalenaSDK, PineExpand, Release } from 'balena-sdk';
+import type {
+	Application,
+	BalenaSDK,
+	PineExpand,
+	PineOptions,
+	PineTypedResult,
+	Release,
+} from 'balena-sdk';
 import type { Preloader } from 'balena-preload';
 
-interface FlagsDef extends DockerConnectionCliFlags {
-	fleet?: string;
-	commit?: string;
-	'splash-image'?: string;
-	'dont-check-arch': boolean;
-	'pin-device-to-release': boolean;
-	'additional-space'?: number;
-	'add-certificate'?: string[];
-	help: void;
-}
-
-interface ArgsDef {
-	image: string;
-}
-
 export default class PreloadCmd extends Command {
 	public static description = stripIndent`
 		Preload a release on a disk image (or Edison zip archive).
@@ -82,19 +73,18 @@ export default class PreloadCmd extends Command {
 		'$ balena preload balena.img',
 	];
 
-	public static args = [
-		{
-			name: 'image',
+	public static args = {
+		image: Args.string({
 			description: 'the image file path',
 			required: true,
-		},
-	];
+		}),
+	};
 
 	public static usage = 'preload <image>';
 
-	public static flags: flags.Input<FlagsDef> = {
+	public static flags = {
 		fleet: cf.fleet,
-		commit: flags.string({
+		commit: Flags.string({
 			description: `\
 The commit hash of the release to preload. Use "current" to specify the current
 release (ignored if no appId is given). The current release is usually also the
@@ -105,27 +95,27 @@ https://github.com/balena-io-examples/staged-releases\
 `,
 			char: 'c',
 		}),
-		'splash-image': flags.string({
+		'splash-image': Flags.string({
 			description: 'path to a png image to replace the splash screen',
 			char: 's',
 		}),
-		'dont-check-arch': flags.boolean({
+		'dont-check-arch': Flags.boolean({
 			default: false,
 			description:
 				'disable architecture compatibility check between image and fleet',
 		}),
-		'pin-device-to-release': flags.boolean({
-			default: false,
+		'pin-device-to-release': Flags.boolean({
+			allowNo: true,
 			description:
 				'pin the preloaded device to the preloaded release on provision',
 			char: 'p',
 		}),
-		'additional-space': flags.integer({
+		'additional-space': Flags.integer({
 			description:
 				'expand the image by this amount of bytes instead of automatically estimating the required amount',
-			parse: (x) => parseAsInteger(x, 'additional-space'),
+			parse: async (x) => parseAsInteger(x, 'additional-space'),
 		}),
-		'add-certificate': flags.string({
+		'add-certificate': Flags.string({
 			description: `\
 Add the given certificate (in PEM format) to /etc/ssl/certs in the preloading container.
 The file name must end with '.crt' and must not be already contained in the preloader's
@@ -137,14 +127,14 @@ Can be repeated to add multiple certificates.\
 		...dockerConnectionCliFlags,
 		// Redefining --dockerPort here (defined already in dockerConnectionCliFlags)
 		// without -p alias, to avoid clash with -p alias of pin-device-to-release
-		dockerPort: flags.integer({
+		dockerPort: Flags.integer({
 			description:
 				'Docker daemon TCP port number (hint: 2375 for balena devices)',
-			parse: (p) => parseAsInteger(p, 'dockerPort'),
+			parse: async (p) => parseAsInteger(p, 'dockerPort'),
 		}),
 		// Not supporting -h for help, because of clash with -h in DockerCliFlags
 		// Revisit this in future release.
-		help: flags.help({}),
+		help: Flags.help({}),
 	};
 
 	public static authenticated = true;
@@ -152,15 +142,13 @@ Can be repeated to add multiple certificates.\
 	public static primary = true;
 
 	public async run() {
-		const { args: params, flags: options } = this.parse<FlagsDef, ArgsDef>(
-			PreloadCmd,
-		);
+		const { args: params, flags: options } = await this.parse(PreloadCmd);
 
 		const balena = getBalenaSdk();
 		const balenaPreload = await import('balena-preload');
 		const visuals = getVisuals();
 		const nodeCleanup = await import('node-cleanup');
-		const { instanceOf } = await import('../errors');
+		const { instanceOf } = await import('../../errors');
 
 		// Check image file exists
 		try {
@@ -183,11 +171,13 @@ Can be repeated to add multiple certificates.\
 		// balena-preload currently does not work with numerical app IDs
 		// Load app here, and use app slug from hereon
 		const fleetSlug: string | undefined = options.fleet
-			? await (await import('../utils/sdk')).getFleetSlug(balena, options.fleet)
+			? await (
+					await import('../../utils/sdk')
+			  ).getFleetSlug(balena, options.fleet)
 			: undefined;
 
 		const progressBars: {
-			[key: string]: ReturnType<typeof getVisuals>['Progress'];
+			[key: string]: InstanceType<ReturnType<typeof getVisuals>['Progress']>;
 		} = {};
 
 		const progressHandler = function (event: {
@@ -201,7 +191,7 @@ Can be repeated to add multiple certificates.\
 		};
 
 		const spinners: {
-			[key: string]: ReturnType<typeof getVisuals>['Spinner'];
+			[key: string]: InstanceType<ReturnType<typeof getVisuals>['Spinner']>;
 		} = {};
 
 		const spinnerHandler = function (event: { name: string; action: string }) {
@@ -223,7 +213,7 @@ Can be repeated to add multiple certificates.\
 		const splashImage = options['splash-image'];
 		const additionalSpace = options['additional-space'];
 		const dontCheckArch = options['dont-check-arch'] || false;
-		const pinDevice = options['pin-device-to-release'] || false;
+		const pinDevice = options['pin-device-to-release'];
 
 		if (dontCheckArch && !fleetSlug) {
 			throw new ExpectedError(
@@ -239,10 +229,10 @@ Can be repeated to add multiple certificates.\
 		}
 
 		// Get a configured dockerode instance
-		const dockerUtils = await import('../utils/docker');
+		const dockerUtils = await import('../../utils/docker');
 		const docker = await dockerUtils.getDocker(options);
 		const preloader = new balenaPreload.Preloader(
-			null,
+			undefined,
 			docker,
 			fleetSlug,
 			commit,
@@ -250,7 +240,7 @@ Can be repeated to add multiple certificates.\
 			splashImage,
 			undefined, // TODO: Currently always undefined, investigate approach in ssh command.
 			dontCheckArch,
-			pinDevice,
+			pinDevice ?? false,
 			certificates,
 			additionalSpace,
 		);
@@ -288,7 +278,7 @@ Can be repeated to add multiple certificates.\
 				preloader.on('error', reject);
 				resolve(
 					this.prepareAndPreload(preloader, balena, {
-						appId: fleetSlug,
+						slug: fleetSlug,
 						commit,
 						pinDevice,
 					}),
@@ -308,7 +298,7 @@ Can be repeated to add multiple certificates.\
 		}
 	}
 
-	readonly applicationExpandOptions: PineExpand<Application> = {
+	readonly applicationExpandOptions = {
 		owns__release: {
 			$select: ['id', 'commit', 'end_timestamp', 'composition'],
 			$expand: {
@@ -329,7 +319,7 @@ Can be repeated to add multiple certificates.\
 		should_be_running__release: {
 			$select: 'commit',
 		},
-	};
+	} satisfies PineExpand<Application>;
 
 	isCurrentCommit(commit: string) {
 		return commit === 'latest' || commit === 'current';
@@ -343,7 +333,7 @@ Can be repeated to add multiple certificates.\
 		} catch {
 			throw new Error(`Device type "${deviceTypeSlug}" not found in API query`);
 		}
-		return (await balena.models.application.getAllDirectlyAccessible({
+		const options = {
 			$select: ['id', 'slug', 'should_track_latest_release'],
 			$expand: this.applicationExpandOptions,
 			$filter: {
@@ -388,11 +378,10 @@ Can be repeated to add multiple certificates.\
 				},
 			},
 			$orderby: 'slug asc',
-		})) as Array<
-			ApplicationWithDeviceType & {
-				should_be_running__release: [Release?];
-			}
-		>;
+		} satisfies PineOptions<Application>;
+		return (await balena.models.application.getAllDirectlyAccessible(
+			options,
+		)) as Array<PineTypedResult<Application, typeof options>>;
 	}
 
 	async selectApplication(deviceTypeSlug: string) {
@@ -403,9 +392,8 @@ Can be repeated to add multiple certificates.\
 		);
 		applicationInfoSpinner.start();
 
-		const applications = await this.getApplicationsWithSuccessfulBuilds(
-			deviceTypeSlug,
-		);
+		const applications =
+			await this.getApplicationsWithSuccessfulBuilds(deviceTypeSlug);
 		applicationInfoSpinner.stop();
 		if (applications.length === 0) {
 			throw new ExpectedError(
@@ -442,16 +430,16 @@ Can be repeated to add multiple certificates.\
 	}
 
 	async offerToDisableAutomaticUpdates(
-		application: Application,
+		application: Pick<Application, 'id' | 'should_track_latest_release'>,
 		commit: string,
-		pinDevice: boolean,
+		pinDevice: boolean | undefined,
 	) {
 		const balena = getBalenaSdk();
 
 		if (
 			this.isCurrentCommit(commit) ||
 			!application.should_track_latest_release ||
-			pinDevice
+			pinDevice != null
 		) {
 			return;
 		}
@@ -470,8 +458,9 @@ through the web dashboard or programatically through the balena API / SDK.
 Documentation about release policies and pinning can be found at:
 https://www.balena.io/docs/learn/deploy/release-strategy/release-policy/
 
-Alternatively, the --pin-device-to-release flag may be used to pin only the
-preloaded device to the selected release.
+Alternatively, the --pin-device-to-release or --no-pin-device-to-release flags may be used
+to avoid this interactive confirmation and pin only the preloaded device to the selected release
+or keep it unpinned respectively.
 
 Would you like to disable automatic updates for this fleet now?\
 `;
@@ -491,28 +480,28 @@ Would you like to disable automatic updates for this fleet now?\
 		});
 	}
 
-	async getAppWithReleases(balenaSdk: BalenaSDK, appId: string) {
-		const { getApplication } = await import('../utils/sdk');
+	async getAppWithReleases(balenaSdk: BalenaSDK, slug: string) {
+		const { getApplication } = await import('../../utils/sdk');
 
-		return (await getApplication(balenaSdk, appId, {
+		return await getApplication(balenaSdk, slug, {
 			$expand: this.applicationExpandOptions,
-		})) as Application & { should_be_running__release: [Release?] };
+		});
 	}
 
 	async prepareAndPreload(
 		preloader: Preloader,
 		balenaSdk: BalenaSDK,
 		options: {
-			appId?: string;
+			slug?: string;
 			commit?: string;
-			pinDevice: boolean;
+			pinDevice?: boolean;
 		},
 	) {
 		await preloader.prepare();
 
-		const application = options.appId
-			? await this.getAppWithReleases(balenaSdk, options.appId)
-			: await this.selectApplication(preloader.config.deviceType);
+		const application = options.slug
+			? await this.getAppWithReleases(balenaSdk, options.slug)
+			: await this.selectApplication(preloader.config!.deviceType);
 
 		let commit: string; // commit hash or the strings 'latest' or 'current'
 
@@ -523,7 +512,7 @@ Would you like to disable automatic updates for this fleet now?\
 			if (this.isCurrentCommit(options.commit)) {
 				if (!appCommit) {
 					throw new Error(
-						`Unexpected empty commit hash for fleet ID "${application.id}"`,
+						`Unexpected empty commit hash for fleet slug "${application.slug}"`,
 					);
 				}
 				// handle `--commit current` (and its `--commit latest` synonym)

lib/commands/push/index.ts

@@ -15,48 +15,27 @@
  * limitations under the License.
  */
 
-import { flags } from '@oclif/command';
-import Command from '../command';
-import * as cf from '../utils/common-flags';
-import { getBalenaSdk, stripIndent } from '../utils/lazy';
-import { dockerignoreHelp, registrySecretsHelp } from '../utils/messages';
+import { Flags, Args } from '@oclif/core';
+import type { Interfaces } from '@oclif/core';
+import Command from '../../command';
+import * as cf from '../../utils/common-flags';
+import { getBalenaSdk, stripIndent } from '../../utils/lazy';
+import { dockerignoreHelp, registrySecretsHelp } from '../../utils/messages';
 import type { BalenaSDK } from 'balena-sdk';
-import { ExpectedError, instanceOf } from '../errors';
-import { RegistrySecrets } from 'resin-multibuild';
-import { lowercaseIfSlug } from '../utils/normalization';
+import { ExpectedError, instanceOf } from '../../errors';
+import { RegistrySecrets } from '@balena/compose/dist/multibuild';
+import { lowercaseIfSlug } from '../../utils/normalization';
 import {
 	applyReleaseTagKeysAndValues,
 	parseReleaseTagKeysAndValues,
-} from '../utils/compose_ts';
+} from '../../utils/compose_ts';
 
 enum BuildTarget {
 	Cloud,
 	Device,
 }
 
-interface ArgsDef {
-	fleetOrDevice: string;
-}
-
-interface FlagsDef {
-	source: string;
-	emulated: boolean;
-	dockerfile?: string; // DeviceDeployOptions.dockerfilePath (alternative Dockerfile)
-	nocache: boolean;
-	pull: boolean;
-	'noparent-check': boolean;
-	'registry-secrets'?: string;
-	nolive: boolean;
-	detached: boolean;
-	service?: string[];
-	system: boolean;
-	env?: string[];
-	'noconvert-eol': boolean;
-	'multi-dockerignore': boolean;
-	'release-tag'?: string[];
-	draft: boolean;
-	help: void;
-}
+type FlagsDef = Interfaces.InferredFlags<typeof PushCmd.flags>;
 
 export default class PushCmd extends Command {
 	public static description = stripIndent`
@@ -97,6 +76,7 @@ export default class PushCmd extends Command {
 		'$ balena push myFleet',
 		'$ balena push myFleet --source <source directory>',
 		'$ balena push myFleet -s <source directory>',
+		'$ balena push myFleet --source <source directory> --note "this is the note for this release"',
 		'$ balena push myFleet --release-tag key1 "" key2 "value2 with spaces"',
 		'$ balena push myorg/myfleet',
 		'',
@@ -110,27 +90,26 @@ export default class PushCmd extends Command {
 		'$ balena push 23c73a1.local --system --service my-service',
 	];
 
-	public static args = [
-		{
-			name: 'fleetOrDevice',
+	public static args = {
+		fleetOrDevice: Args.string({
 			description:
 				'fleet name or slug, or local device IP address or ".local" hostname',
 			required: true,
 			parse: lowercaseIfSlug,
-		},
-	];
+		}),
+	};
 
 	public static usage = 'push <fleetOrDevice>';
 
-	public static flags: flags.Input<FlagsDef> = {
-		source: flags.string({
+	public static flags = {
+		source: Flags.string({
 			description: stripIndent`
 				Source directory to be sent to balenaCloud or balenaOS device
 				(default: current working dir)`,
 			char: 's',
 			default: '.',
 		}),
-		emulated: flags.boolean({
+		emulated: Flags.boolean({
 			description: stripIndent`
 				Don't use the faster, native balenaCloud ARM builders; force slower QEMU ARM
 				emulation on Intel x86-64 builders. This flag is sometimes used to investigate
@@ -138,12 +117,11 @@ export default class PushCmd extends Command {
 			char: 'e',
 			default: false,
 		}),
-		// TODO:  docker-compose naming
-		dockerfile: flags.string({
+		dockerfile: Flags.string({
 			description:
 				'Alternative Dockerfile name/path, relative to the source folder',
 		}),
-		nocache: flags.boolean({
+		nocache: Flags.boolean({
 			description: stripIndent`
 				Don't use cached layers of previously built images for this project. This
 				ensures that the latest base image and packages are pulled. Note that build
@@ -154,18 +132,18 @@ export default class PushCmd extends Command {
 			char: 'c',
 			default: false,
 		}),
-		pull: flags.boolean({
+		pull: Flags.boolean({
 			description: stripIndent`
 				When pushing to a local device, force the base images to be pulled again.
 				Currently this option is ignored when pushing to the balenaCloud builders.`,
 			default: false,
 		}),
-		'noparent-check': flags.boolean({
+		'noparent-check': Flags.boolean({
 			description: stripIndent`
 				Disable project validation check of 'docker-compose.yml' file in parent folder`,
 			default: false,
 		}),
-		'registry-secrets': flags.string({
+		'registry-secrets': Flags.string({
 			description: stripIndent`
 				Path to a local YAML or JSON file containing Docker registry passwords used
 				to pull base images. Note that if registry-secrets are not provided on the
@@ -173,15 +151,15 @@ export default class PushCmd extends Command {
 				used (usually $HOME/.balena/secrets.yml|.json)`,
 			char: 'R',
 		}),
-		nolive: flags.boolean({
+		nolive: Flags.boolean({
 			description: stripIndent`
 				Don't run a live session on this push. The filesystem will not be monitored,
 				and changes will not be synchronized to any running containers. Note that both
-				this flag and --detached and required to cause the process to end once the
+				this flag and --detached are required to cause the process to end once the
 				initial build has completed.`,
 			default: false,
 		}),
-		detached: flags.boolean({
+		detached: Flags.boolean({
 			description: stripIndent`
 				When pushing to the cloud, this option will cause the build to start, then
 				return execution back to the shell, with the status and release ID (if
@@ -190,20 +168,20 @@ export default class PushCmd extends Command {
 			char: 'd',
 			default: false,
 		}),
-		service: flags.string({
+		service: Flags.string({
 			description: stripIndent`
 				Reject logs not originating from this service.
 				This can be used in combination with --system and other --service flags.
 				Only valid when pushing to a local mode device.`,
 			multiple: true,
 		}),
-		system: flags.boolean({
+		system: Flags.boolean({
 			description: stripIndent`
 				Only show system logs. This can be used in combination with --service.
 				Only valid when pushing to a local mode device.`,
 			default: false,
 		}),
-		env: flags.string({
+		env: Flags.string({
 			description: stripIndent`
 				When performing a push to device, run the built containers with environment
 				variables provided with this argument. Environment variables can be applied
@@ -215,17 +193,17 @@ export default class PushCmd extends Command {
 			`,
 			multiple: true,
 		}),
-		'noconvert-eol': flags.boolean({
+		'noconvert-eol': Flags.boolean({
 			description: `Don't convert line endings from CRLF (Windows format) to LF (Unix format).`,
 			default: false,
 		}),
-		'multi-dockerignore': flags.boolean({
+		'multi-dockerignore': Flags.boolean({
 			description:
 				'Have each service use its own .dockerignore file. See "balena help push".',
 			char: 'm',
 			default: false,
 		}),
-		'release-tag': flags.string({
+		'release-tag': Flags.string({
 			description: stripIndent`
 				Set release tags if the image build is successful (balenaCloud only). Multiple
 				arguments may be provided, alternating tag keys and values (see examples).
@@ -234,7 +212,7 @@ export default class PushCmd extends Command {
 			multiple: true,
 			exclusive: ['detached'],
 		}),
-		draft: flags.boolean({
+		draft: Flags.boolean({
 			description: stripIndent`
 				Instruct the builder to create the release as a draft. Draft releases are ignored
 				by the 'track latest' release policy but can be used through release pinning.
@@ -242,21 +220,20 @@ export default class PushCmd extends Command {
 				as final by default unless this option is given.`,
 			default: false,
 		}),
+		note: Flags.string({ description: 'The notes for this release' }),
 		help: cf.help,
 	};
 
 	public static primary = true;
 
 	public async run() {
-		const { args: params, flags: options } = this.parse<FlagsDef, ArgsDef>(
-			PushCmd,
-		);
+		const { args: params, flags: options } = await this.parse(PushCmd);
 
 		const logger = await Command.getLogger();
 		logger.logDebug(`Using build source directory: ${options.source} `);
 
 		const sdk = getBalenaSdk();
-		const { validateProjectDirectory } = await import('../utils/compose_ts');
+		const { validateProjectDirectory } = await import('../../utils/compose_ts');
 		const { dockerfilePath, registrySecrets } = await validateProjectDirectory(
 			sdk,
 			{
@@ -299,8 +276,8 @@ export default class PushCmd extends Command {
 		dockerfilePath: string,
 		registrySecrets: RegistrySecrets,
 	) {
-		const remote = await import('../utils/remote-build');
-		const { getApplication } = await import('../utils/sdk');
+		const remote = await import('../../utils/remote-build');
+		const { getApplication } = await import('../../utils/sdk');
 
 		// Check for invalid options
 		const localOnlyOptions: Array<keyof FlagsDef> = [
@@ -326,7 +303,7 @@ export default class PushCmd extends Command {
 		]);
 
 		const application = await getApplication(sdk, appNameOrSlug, {
-			$select: ['app_name', 'slug'],
+			$select: 'slug',
 		});
 
 		const opts = {
@@ -355,6 +332,9 @@ export default class PushCmd extends Command {
 				releaseTagKeys,
 				releaseTagValues,
 			);
+			if (options.note) {
+				await sdk.models.release.setNote(releaseId, options.note);
+			}
 		} else if (releaseTagKeys.length > 0) {
 			throw new Error(stripIndent`
 				A release ID could not be parsed out of the builder's output.
@@ -376,7 +356,7 @@ export default class PushCmd extends Command {
 			'is only valid when pushing to a fleet',
 		);
 
-		const deviceDeploy = await import('../utils/device/deploy');
+		const deviceDeploy = await import('../../utils/device/deploy');
 
 		try {
 			await deviceDeploy.deployToDevice({
@@ -396,7 +376,7 @@ export default class PushCmd extends Command {
 				convertEol: !options['noconvert-eol'],
 			});
 		} catch (e) {
-			const { BuildError } = await import('../utils/device/errors');
+			const { BuildError } = await import('../../utils/device/errors');
 			if (instanceOf(e, BuildError)) {
 				throw new ExpectedError(e.toString());
 			} else {
@@ -406,7 +386,9 @@ export default class PushCmd extends Command {
 	}
 
 	protected async getBuildTarget(appOrDevice: string): Promise<BuildTarget> {
-		const { validateLocalHostnameOrIp } = await import('../utils/validation');
+		const { validateLocalHostnameOrIp } = await import(
+			'../../utils/validation'
+		);
 
 		return validateLocalHostnameOrIp(appOrDevice)
 			? BuildTarget.Device

lib/commands/release/finalize.ts

@@ -15,19 +15,10 @@
  * limitations under the License.
  */
 
-import { flags } from '@oclif/command';
+import { commitOrIdArg } from '.';
 import Command from '../../command';
 import * as cf from '../../utils/common-flags';
 import { getBalenaSdk, stripIndent } from '../../utils/lazy';
-import { tryAsInteger } from '../../utils/validation';
-
-interface FlagsDef {
-	help: void;
-}
-
-interface ArgsDef {
-	commitOrId: string | number;
-}
 
 export default class ReleaseFinalizeCmd extends Command {
 	public static description = stripIndent`
@@ -51,23 +42,21 @@ export default class ReleaseFinalizeCmd extends Command {
 
 	public static usage = 'release finalize <commitOrId>';
 
-	public static flags: flags.Input<FlagsDef> = {
+	public static flags = {
 		help: cf.help,
 	};
 
-	public static args = [
-		{
-			name: 'commitOrId',
+	public static args = {
+		commitOrId: commitOrIdArg({
 			description: 'the commit or ID of the release to finalize',
 			required: true,
-			parse: (commitOrId: string) => tryAsInteger(commitOrId),
-		},
-	];
+		}),
+	};
 
 	public static authenticated = true;
 
 	public async run() {
-		const { args: params } = this.parse<FlagsDef, ArgsDef>(ReleaseFinalizeCmd);
+		const { args: params } = await this.parse(ReleaseFinalizeCmd);
 
 		const balena = getBalenaSdk();
 

lib/commands/release/index.ts

@@ -15,64 +15,62 @@
  * limitations under the License.
  */
 
-import { flags } from '@oclif/command';
+import { Flags, Args, type Interfaces } from '@oclif/core';
 import Command from '../../command';
 import * as cf from '../../utils/common-flags';
 import { getBalenaSdk, getVisuals, stripIndent } from '../../utils/lazy';
 import type * as BalenaSdk from 'balena-sdk';
 import jsyaml = require('js-yaml');
 import { tryAsInteger } from '../../utils/validation';
+import { jsonInfo } from '../../utils/messages';
 
-interface FlagsDef {
-	help: void;
-	composition?: boolean;
-}
+export const commitOrIdArg = Args.custom({
+	parse: async (commitOrId: string) => tryAsInteger(commitOrId),
+});
 
-interface ArgsDef {
-	commitOrId: string | number;
-}
+type FlagsDef = Interfaces.InferredFlags<typeof ReleaseCmd.flags>;
 
 export default class ReleaseCmd extends Command {
 	public static description = stripIndent`
 		Get info for a release.
+
+		${jsonInfo.split('\n').join('\n\t\t')}
 `;
 	public static examples = [
 		'$ balena release a777f7345fe3d655c1c981aa642e5555',
 		'$ balena release 1234567',
+		'$ balena release d3f3151f5ad25ca6b070aa4d08296aca --json',
 	];
 
 	public static usage = 'release <commitOrId>';
 
-	public static flags: flags.Input<FlagsDef> = {
+	public static flags = {
+		json: cf.json,
 		help: cf.help,
-		composition: flags.boolean({
+		composition: Flags.boolean({
 			default: false,
 			char: 'c',
 			description: 'Return the release composition',
 		}),
 	};
 
-	public static args = [
-		{
-			name: 'commitOrId',
+	public static args = {
+		commitOrId: commitOrIdArg({
 			description: 'the commit or ID of the release to get information',
 			required: true,
-			parse: (commitOrId: string) => tryAsInteger(commitOrId),
-		},
-	];
+		}),
+	};
 
 	public static authenticated = true;
 
 	public async run() {
-		const { args: params, flags: options } = this.parse<FlagsDef, ArgsDef>(
-			ReleaseCmd,
-		);
+		const { args: params, flags: options } = await this.parse(ReleaseCmd);
 
 		const balena = getBalenaSdk();
 		if (options.composition) {
 			await this.showComposition(params.commitOrId, balena);
 		} else {
-			await this.showReleaseInfo(params.commitOrId, balena);
+			await this.showReleaseInfo(params.commitOrId, balena, options);
 		}
 	}
 
@@ -90,6 +88,7 @@ export default class ReleaseCmd extends Command {
 	async showReleaseInfo(
 		commitOrId: string | number,
 		balena: BalenaSdk.BalenaSDK,
+		options: FlagsDef,
 	) {
 		const fields: Array<keyof BalenaSdk.Release> = [
 			'id',
@@ -104,7 +103,7 @@ export default class ReleaseCmd extends Command {
 		];
 
 		const release = await balena.models.release.get(commitOrId, {
-			$select: fields,
+			...(!options.json && { $select: fields }),
 			$expand: {
 				release_tag: {
 					$select: ['tag_key', 'value'],
@@ -112,17 +111,21 @@ export default class ReleaseCmd extends Command {
 			},
 		});
 
-		const tagStr = release
-			.release_tag!.map((t) => `${t.tag_key}=${t.value}`)
-			.join('\n');
+		if (options.json) {
+			console.log(JSON.stringify(release, null, 4));
+		} else {
+			const tagStr = release
+				.release_tag!.map((t) => `${t.tag_key}=${t.value}`)
+				.join('\n');
 
-		const _ = await import('lodash');
-		const values = _.mapValues(
-			release,
-			(val) => val ?? 'N/a',
-		) as Dictionary<string>;
-		values['tags'] = tagStr;
+			const _ = await import('lodash');
+			const values = _.mapValues(
+				release,
+				(val) => val ?? 'N/a',
+			) as Dictionary<string>;
+			values['tags'] = tagStr;
 
-		console.log(getVisuals().table.vertical(values, [...fields, 'tags']));
+			console.log(getVisuals().table.vertical(values, [...fields, 'tags']));
+		}
 	}
 }

lib/commands/release/invalidate.ts

@@ -0,0 +1,70 @@
+/**
+ * @license
+ * Copyright 2016-2020 Balena Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { commitOrIdArg } from '.';
+import Command from '../../command';
+import * as cf from '../../utils/common-flags';
+import { getBalenaSdk, stripIndent } from '../../utils/lazy';
+
+export default class ReleaseInvalidateCmd extends Command {
+	public static description = stripIndent`
+		Invalidate a release.
+
+		Invalidate a release.
+
+		Invalid releases are not automatically deployed to devices tracking the latest
+		release. For an invalid release to be deployed to a device, the device should be
+		explicity pinned to that release.
+`;
+	public static examples = [
+		'$ balena release invalidate a777f7345fe3d655c1c981aa642e5555',
+		'$ balena release invalidate 1234567',
+	];
+
+	public static usage = 'release invalidate <commitOrId>';
+
+	public static flags = {
+		help: cf.help,
+	};
+
+	public static args = {
+		commitOrId: commitOrIdArg({
+			description: 'the commit or ID of the release to invalidate',
+			required: true,
+		}),
+	};
+
+	public static authenticated = true;
+
+	public async run() {
+		const { args: params } = await this.parse(ReleaseInvalidateCmd);
+
+		const balena = getBalenaSdk();
+
+		const release = await balena.models.release.get(params.commitOrId, {
+			$select: ['id', 'is_invalidated'],
+		});
+
+		if (release.is_invalidated) {
+			console.log(`Release ${params.commitOrId} is already invalidated!`);
+			return;
+		}
+
+		await balena.models.release.setIsInvalidated(release.id, true);
+		console.log(`Release ${params.commitOrId} invalidated`);
+	}
+}