@granite-js/forge-cli 0.0.0-dev-20250725013859

package/README.md

@@ -0,0 +1,3 @@
+# @granite-js/forge
+
+A CLI tool for managing Granite applications

package/bin/index.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+
+import '../dist/index.js';

package/dist/index.js

@@ -0,0 +1,255 @@
+import { Command } from "@commander-js/extra-typings";
+import path from "path";
+import { fromNodeProviderChain } from "@aws-sdk/credential-providers";
+import { loadSharedConfigFiles } from "@aws-sdk/shared-ini-file-loader";
+import * as p$3 from "@clack/prompts";
+import * as p$2 from "@clack/prompts";
+import * as p$1 from "@clack/prompts";
+import * as p from "@clack/prompts";
+import { loadConfig } from "@granite-js/cli";
+import { DeployManager, NoSuchKey, S3Client } from "@granite-js/deployment-manager";
+import * as v from "valibot";
+import { v7 } from "uuid";
+import { createReadStream, createWriteStream } from "fs";
+import { pipeline } from "stream/promises";
+import { createGzip } from "zlib";
+
+//#region src/utils/generateDeploymentId.ts
+function generateDeploymentId() {
+	return v7();
+}
+
+//#endregion
+//#region src/utils/gzip.ts
+/**
+* Compresses inputFile using gzip and saves it to outputFile.
+*
+* @param {string} inputFile  - Path to the source file to compress
+* @param {string} outputFile - Path to save the gzipped file (recommended to use .gz extension)
+* @throws Throws an error if compression fails
+*/
+async function gzipFile({ inputFile, outputFile }) {
+	await pipeline(createReadStream(inputFile), createGzip(), createWriteStream(outputFile));
+}
+
+//#endregion
+//#region src/utils/handlePrompts.ts
+function handlePrompts(title, task) {
+	return (...args) => {
+		p$3.intro(title);
+		try {
+			const result = task.call(null, ...args);
+			if (result instanceof Promise) result.catch(promptErrorHandler);
+		} catch (error) {
+			promptErrorHandler(error);
+		}
+	};
+}
+function promptErrorHandler(error) {
+	p$3.log.error(error instanceof Error ? error.message : String(error));
+	process.exit(1);
+}
+
+//#endregion
+//#region src/operations/deploy.ts
+const deploy$1 = handlePrompts("Start deployment", deployImpl);
+async function deployImpl({ androidBundle, iosBundle, appName, tag }, context) {
+	const { s3Client } = context;
+	const gzippedAndroidBundle = `${androidBundle}.gz`;
+	const gzippedIosBundle = `${iosBundle}.gz`;
+	await Promise.all([gzipFile({
+		inputFile: androidBundle,
+		outputFile: gzippedAndroidBundle
+	}), gzipFile({
+		inputFile: iosBundle,
+		outputFile: gzippedIosBundle
+	})]);
+	const deploymentId = generateDeploymentId();
+	const deployedAt = new Date();
+	let spinner = p$2.spinner();
+	spinner.start("Fetching current deployment state...");
+	const currentDeploymentState = await DeployManager.readDeploymentState(appName, { s3Client }).catch(handleReadDeploymentStateError);
+	spinner.stop("Successfully fetched current deployment state");
+	let newDeploymentState;
+	if (currentDeploymentState != null) {
+		p$2.log.info("Planning rollout...");
+		newDeploymentState = await DeployManager.planRollout(currentDeploymentState, {
+			progress: 100,
+			targetDeploymentId: deploymentId
+		});
+		switch (newDeploymentState.type) {
+			case "STABLE":
+				p$2.log.info(`Stable deployment planned (target: ${newDeploymentState.deploymentId})`);
+				break;
+			case "CANARY":
+			case "PENDING":
+				console.error("unimplemented yet");
+				process.exit(1);
+		}
+	} else {
+		p$2.log.warn("No deployment state found");
+		newDeploymentState = {
+			type: "STABLE",
+			deploymentId
+		};
+	}
+	if (process.stdin.isTTY) {
+		const confirmed = await p$2.confirm({ message: `Are you sure you want to deploy ${appName}?` });
+		if (!confirmed || p$2.isCancel(confirmed)) {
+			p$2.outro("Deployment cancelled");
+			process.exit(0);
+		}
+	}
+	await p$2.tasks([{
+		bundlePath: gzippedAndroidBundle,
+		platform: "android"
+	}, {
+		bundlePath: gzippedIosBundle,
+		platform: "ios"
+	}].map(({ bundlePath, platform }) => ({
+		title: `Uploading bundle... (${platform})`,
+		task: async () => {
+			DeployManager.uploadBundle({
+				bundlePath,
+				appName,
+				platform,
+				tag,
+				deploymentId,
+				deployedAt
+			}, { s3Client });
+			return "Bundle uploaded";
+		}
+	})));
+	spinner = p$2.spinner();
+	spinner.start("Updating bundle list...");
+	await DeployManager.updateBundleList({
+		appName,
+		newDeploymentInfo: {
+			deployedAt: deployedAt.getTime(),
+			deploymentId
+		}
+	}, { s3Client });
+	spinner.stop("Bundle list updated");
+	spinner = p$2.spinner();
+	spinner.start(`Deploying ${appName}@${deploymentId}...`);
+	await DeployManager.rollout({
+		state: newDeploymentState,
+		appName
+	}, { s3Client });
+	spinner.stop(`Deployed successfully! (Deployment ID: ${deploymentId})`);
+	p$2.outro("Done");
+}
+function handleReadDeploymentStateError(error) {
+	if (error instanceof NoSuchKey) return null;
+	throw error;
+}
+
+//#endregion
+//#region src/commands/deploy.ts
+const envSchema = v.object({
+	AWS_REGION: v.string(),
+	AWS_ACCESS_KEY_ID: v.string(),
+	AWS_SECRET_ACCESS_KEY: v.string(),
+	AWS_SESSION_TOKEN: v.optional(v.string())
+});
+const awsCredentialsProvider = fromNodeProviderChain();
+function deploy() {
+	return new Command("deploy").description("Deploy a Granite application").requiredOption("--bucket <BUCKET>", "AWS bucket").action(async (options) => {
+		const [config, awsCredentials, region] = await Promise.all([
+			loadConfig(),
+			awsCredentialsProvider(),
+			getRegion()
+		]);
+		const envResult = v.safeParse(envSchema, {
+			AWS_REGION: region,
+			AWS_ACCESS_KEY_ID: awsCredentials.accessKeyId,
+			AWS_SECRET_ACCESS_KEY: awsCredentials.secretAccessKey,
+			AWS_SESSION_TOKEN: awsCredentials.sessionToken
+		});
+		if (!envResult.success) {
+			const missingVars = envResult.issues.map((issue) => {
+				const path$1 = issue.path?.[0];
+				return path$1 ? `process.env.${path$1.key}` : "unknown variable";
+			});
+			p$1.log.error(`Required environment variables are not set:`);
+			for (const missingVar of missingVars) p$1.log.error(`${missingVar}`);
+			process.exit(1);
+		}
+		await deploy$1({
+			appName: config.appName,
+			iosBundle: path.join(config.outdir, `bundle.ios.hbc`),
+			androidBundle: path.join(config.outdir, `bundle.android.hbc`)
+		}, { s3Client: new S3Client({
+			region,
+			bucket: options.bucket,
+			credentials: {
+				accessKeyId: envResult.output.AWS_ACCESS_KEY_ID,
+				secretAccessKey: envResult.output.AWS_SECRET_ACCESS_KEY,
+				sessionToken: envResult.output.AWS_SESSION_TOKEN
+			}
+		}) });
+	});
+}
+async function getRegion() {
+	const { configFile } = await loadSharedConfigFiles();
+	const envRegion = process.env.AWS_REGION;
+	if (envRegion != null) return envRegion;
+	const currentProfile = process.env.AWS_PROFILE;
+	if (currentProfile != null) {
+		const region = configFile?.[currentProfile]?.region;
+		if (region != null) return region;
+	}
+	const defaultRegion = configFile.default?.region;
+	return defaultRegion;
+}
+
+//#endregion
+//#region src/helpers/command.ts
+function withS3Client(command) {
+	return command.requiredOption("--region <REGION>", "AWS region").requiredOption("--bucket <BUCKET>", "AWS bucket").requiredOption("--access-key-id <ACCESS_KEY_ID>", "AWS access key ID").requiredOption("--secret-access-key <SECRET_ACCESS_KEY>", "AWS secret access key").option("--session-token <SESSION_TOKEN>", "AWS session token");
+}
+
+//#endregion
+//#region src/operations/deployList.ts
+const deployList$1 = handlePrompts("Deployment list", deployListImpl);
+async function deployListImpl({ appName }, context) {
+	const { s3Client } = context;
+	const spinner = p.spinner();
+	spinner.start("Fetching deployment list...");
+	const deployments = await DeployManager.readBundleList(appName, { s3Client }).catch(handleReadBundleListError);
+	spinner.stop("Successfully fetched deployment list");
+	deployments.slice(0, 20).forEach((deployment, index) => {
+		p.log.info(`${index + 1}. ${deployment.deploymentId} (Deployed at: ${new Date(deployment.deployedAt).toLocaleString()})`);
+	});
+	p.outro(deployments.length ? `${deployments.length} deployment(s) found` : "No deployments found");
+}
+function handleReadBundleListError(error) {
+	if (error instanceof NoSuchKey) return [];
+	throw error;
+}
+
+//#endregion
+//#region src/commands/deployList.ts
+function deployList() {
+	return withS3Client(new Command("deploy-list")).description("Show the deployment list of a Granite application").requiredOption("-n, --app-name <APP_NAME>", "Granite application name").action(async (options) => {
+		await deployList$1(options, { s3Client: new S3Client({
+			region: options.region,
+			bucket: options.bucket,
+			credentials: {
+				accessKeyId: options.accessKeyId,
+				secretAccessKey: options.secretAccessKey,
+				sessionToken: options.sessionToken
+			}
+		}) });
+	});
+}
+
+//#endregion
+//#region src/index.ts
+const program = new Command("granite-forge");
+program.description("A CLI tool for managing Granite applications");
+program.addCommand(deploy());
+program.addCommand(deployList());
+program.parse();
+
+//#endregion

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@granite-js/forge-cli",
+  "description": "A CLI tool for managing Granite applications",
+  "type": "module",
+  "version": "0.0.0-dev-20250725013859",
+  "bin": {
+    "granite-forge": "./bin/index.js"
+  },
+  "files": [
+    "dist",
+    "bin",
+    "package.json"
+  ],
+  "scripts": {
+    "prepack": "yarn build",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest --run --coverage --passWithNoTests",
+    "build": "tsdown"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.2",
+    "@vitest/coverage-v8": "^3.1.4",
+    "tsdown": "^0.11.13",
+    "typescript": "^5.8.3",
+    "vitest": "^3.1.4"
+  },
+  "dependencies": {
+    "@aws-sdk/credential-providers": "^3.817.0",
+    "@aws-sdk/shared-ini-file-loader": "^3.374.0",
+    "@clack/prompts": "^0.10.1",
+    "@commander-js/extra-typings": "^14.0.0",
+    "@granite-js/cli": "workspace:*",
+    "@granite-js/deployment-manager": "workspace:*",
+    "commander": "^14.0.0",
+    "uuid": "^11.1.0",
+    "valibot": "^1.1.0"
+  }
+}