feat: add license check to setup wizard and status bar check (#24)

Adds checking for localstack license during the setup process and as a
part of `isSetupRequired` checks on startup and in status bar.

Also adds proactive license activation to mitigate caching issues and
unnecessary redirects when activation can be done in the background.

License check and activation are performed right after authentication.

Updated setup flow with license activation:


![auth_and_license_activation_in_setup_wizard](https://github.com/user-attachments/assets/25fd1190-43ff-42c8-a939-eaea10f99f8a)


Note: Not adding telemetry yet as I want to clarify schema update
process first - this PR adds another step in the middle of setup flow
therefore step positions shift.

---------

Co-authored-by: Cristian Pallarés <[email protected]>

Author: tiurin

src/plugins/setup.ts

@@ -1,5 +1,3 @@
-import os from "node:os";
-
 import { commands, ProgressLocation, window } from "vscode";
 
 import { createPlugin } from "../plugins.ts";
@@ -10,6 +8,11 @@ import {
 } from "../utils/authenticate.ts";
 import { configureAwsProfiles } from "../utils/configure-aws.ts";
 import { runInstallProcess } from "../utils/install.ts";
+import {
+	activateLicense,
+	checkIsLicenseValid,
+	activateLicenseUntilValid,
+} from "../utils/license.ts";
 import { minDelay } from "../utils/promises.ts";
 
 export default createPlugin(
@@ -122,8 +125,6 @@ export default createPlugin(
 								progress.report({
 									message:
 										"Waiting for authentication response from the browser...",
-									// message: "Waiting for browser response...",
-									// message: "Waiting for authentication response...",
 								});
 								const { authToken } = await minDelay(
 									requestAuthentication(context, cancellationToken),
@@ -146,7 +147,6 @@ export default createPlugin(
 
 								/////////////////////////////////////////////////////////////////////
 								progress.report({
-									// message: "Authenticating...",
 									message: "Authenticating to file...",
 								});
 								await minDelay(saveAuthToken(authToken, outputChannel));
@@ -168,6 +168,38 @@ export default createPlugin(
 								}
 							}
 
+							/////////////////////////////////////////////////////////////////////
+							progress.report({ message: "Checking LocalStack license..." });
+
+							// If an auth token has just been obtained or LocalStack has never been started,
+							// then there will be no license info to be reported by `localstack license info`.
+							// Also, an expired license could be cached.
+							// Activating the license pre-emptively to know its state during the setup process.
+							const licenseIsValid = await minDelay(
+								activateLicense(outputChannel).then(() =>
+									checkIsLicenseValid(outputChannel),
+								),
+							);
+							if (!licenseIsValid) {
+								progress.report({
+									message:
+										"License is not valid or not assigned. Open License settings page to activate it.",
+								});
+
+								commands.executeCommand("localstack.openLicensePage");
+
+								await activateLicenseUntilValid(
+									outputChannel,
+									cancellationToken,
+								);
+							}
+
+							if (cancellationToken.isCancellationRequested) {
+								return;
+							}
+
+							//TODO add telemetry
+
 							/////////////////////////////////////////////////////////////////////
 							progress.report({
 								message: "Configuring AWS profiles...",

src/utils/authenticate.ts

@@ -1,4 +1,3 @@
-import { createHash } from "node:crypto";
 import * as fs from "node:fs/promises";
 import * as os from "node:os";
 import * as path from "node:path";
@@ -11,7 +10,6 @@ import type {
 import { env, Uri, window } from "vscode";
 
 import { assertIsError } from "./assert.ts";
-import { execLocalStack } from "./cli.ts";
 
 /**
  * Registers a {@link UriHandler} that waits for an authentication token from the browser,
@@ -114,21 +112,6 @@ export async function saveAuthToken(
 	}
 }
 
-const LICENSE_VALIDITY_MARKER = "license validity: valid";
-
-export async function checkIsLicenseValid(outputChannel: LogOutputChannel) {
-	try {
-		const licenseInfoResponse = await execLocalStack(["license", "info"], {
-			outputChannel,
-		});
-		return licenseInfoResponse.stdout.includes(LICENSE_VALIDITY_MARKER);
-	} catch (error) {
-		outputChannel.error(error instanceof Error ? error : String(error));
-
-		return undefined;
-	}
-}
-
 /**
  * Checks if the user is authenticated by validating the stored auth token.
  *

src/utils/license.ts

@@ -0,0 +1,46 @@
+import type { CancellationToken, LogOutputChannel } from "vscode";
+
+import { execLocalStack } from "./cli.ts";
+
+const LICENSE_VALIDITY_MARKER = "license validity: valid";
+
+export async function checkIsLicenseValid(outputChannel: LogOutputChannel) {
+	try {
+		const licenseInfoResponse = await execLocalStack(["license", "info"], {
+			outputChannel,
+		});
+		return licenseInfoResponse.stdout.includes(LICENSE_VALIDITY_MARKER);
+	} catch (error) {
+		outputChannel.error(error instanceof Error ? error : String(error));
+
+		return false;
+	}
+}
+
+export async function activateLicense(outputChannel: LogOutputChannel) {
+	try {
+		await execLocalStack(["license", "activate"], {
+			outputChannel,
+		});
+	} catch (error) {
+		outputChannel.error(error instanceof Error ? error : String(error));
+	}
+}
+
+export async function activateLicenseUntilValid(
+	outputChannel: LogOutputChannel,
+	cancellationToken: CancellationToken,
+): Promise<void> {
+	while (true) {
+		if (cancellationToken.isCancellationRequested) {
+			break;
+		}
+		const licenseIsValid = await checkIsLicenseValid(outputChannel);
+		if (licenseIsValid) {
+			break;
+		}
+		await activateLicense(outputChannel);
+		// Wait before trying again
+		await new Promise((resolve) => setTimeout(resolve, 1000));
+	}
+}

src/utils/manage.ts

@@ -2,9 +2,9 @@ import { v7 as uuidv7 } from "uuid";
 import type { ExtensionContext, LogOutputChannel, MessageItem } from "vscode";
 import { commands, env, Uri, window } from "vscode";
 
-import { checkIsLicenseValid } from "./authenticate.ts";
 import { spawnLocalStack } from "./cli.ts";
 import { exec } from "./exec.ts";
+import { checkIsLicenseValid } from "./license.ts";
 import type { Telemetry } from "./telemetry.ts";
 
 export type LocalstackStatus = "running" | "starting" | "stopping" | "stopped";
@@ -183,7 +183,12 @@ export async function stopLocalStack(
 
 export async function openLicensePage() {
 	const url = new URL("https://app.localstack.cloud/settings/auth-tokens");
-	await env.openExternal(Uri.parse(url.toString()));
+	const openSuccessful = await env.openExternal(Uri.parse(url.toString()));
+	if (!openSuccessful) {
+		window.showErrorMessage(
+			`Open LocalStack License page in browser by entering the URL manually: ${url.toString()}`,
+		);
+	}
 }
 
 async function showInformationMessage(

src/utils/promises.ts

@@ -1,9 +1,9 @@
 import pMinDelay from "p-min-delay";
 
 /**
- * Setting up a minimum wait time of 1s allows users
+ * Setting up a minimum wait time allows users
  * to visually grasp the text before it goes away, if
- * the task was fast (less than 0.5s).
+ * the task was faster than the minimum wait time.
  */
 const MIN_TIME_BETWEEN_STEPS_MS = 500;
 

src/utils/setup.ts

@@ -3,17 +3,20 @@ import type { LogOutputChannel } from "vscode";
 import { checkIsAuthenticated } from "./authenticate.ts";
 import { checkIsProfileConfigured } from "./configure-aws.ts";
 import { checkLocalstackInstalled } from "./install.ts";
+import { checkIsLicenseValid } from "./license.ts";
 
 export async function checkIsSetupRequired(
 	outputChannel: LogOutputChannel,
 ): Promise<boolean> {
-	const [isInstalled, isAuthenticated, isProfileConfigured] = await Promise.all(
-		[
+	const [isInstalled, isAuthenticated, isLicenseValid, isProfileConfigured] =
+		await Promise.all([
 			checkLocalstackInstalled(outputChannel),
 			checkIsAuthenticated(),
+			checkIsLicenseValid(outputChannel),
 			checkIsProfileConfigured(),
-		],
-	);
+		]);
 
-	return !isInstalled || !isAuthenticated || !isProfileConfigured;
+	return (
+		!isInstalled || !isAuthenticated || !isLicenseValid || !isProfileConfigured
+	);
 }