@geekmidas/cli 0.44.0 → 0.46.0

package/dist/index.mjs

@@ -1,9 +1,9 @@
 #!/usr/bin/env -S npx tsx
-import { __require, getAppBuildOrder, getDependencyEnvVars, getDeployTargetError, isDeployTargetSupported } from "./workspace-D_6ZCaR_.mjs";
-import { getAppNameFromCwd, loadAppConfig, loadConfig, loadWorkspaceConfig, parseModuleConfig } from "./config-C0b0jdmU.mjs";
-import { ConstructGenerator, EndpointGenerator, OPENAPI_OUTPUT_PATH, OpenApiTsGenerator, generateOpenApi, openapiCommand, resolveOpenApiConfig } from "./openapi-D3pA6FfZ.mjs";
+import { __require, getAppBuildOrder, getDependencyEnvVars, getDeployTargetError, isDeployTargetSupported } from "./workspace-DLFRaDc-.mjs";
+import { getAppNameFromCwd, loadAppConfig, loadConfig, loadWorkspaceConfig, parseModuleConfig } from "./config-C3LSBNSl.mjs";
+import { ConstructGenerator, EndpointGenerator, OPENAPI_OUTPUT_PATH, OpenApiTsGenerator, generateOpenApi, openapiCommand, resolveOpenApiConfig } from "./openapi-C3C-BzIZ.mjs";
 import { getKeyPath, maskPassword, readStageSecrets, secretsExist, setCustomSecret, toEmbeddableSecrets, writeStageSecrets } from "./storage-Dhst7BhI.mjs";
-import { DokployApi } from "./dokploy-api-DWsqNjwP.mjs";
+import { DokployApi } from "./dokploy-api-b6usLLKk.mjs";
 import { encryptSecrets } from "./encryption-BC4MAODn.mjs";
 import { generateReactQueryCommand } from "./openapi-react-query-ZoP9DPbY.mjs";
 import { createRequire } from "node:module";
@@ -28,7 +28,7 @@ import prompts from "prompts";
 
 //#region package.json
 var name = "@geekmidas/cli";
-var version = "0.44.0";
+var version = "0.46.0";
 var description = "CLI tools for building Lambda handlers, server applications, and generating OpenAPI specs";
 var private$1 = false;
 var type = "module";
@@ -227,7 +227,7 @@ const logger$10 = console;
 * Validate Dokploy token by making a test API call
 */
 async function validateDokployToken(endpoint, token) {
-	const { DokployApi: DokployApi$1 } = await import("./dokploy-api-tZSZaHd9.mjs");
+	const { DokployApi: DokployApi$1 } = await import("./dokploy-api-C1JgU9Vr.mjs");
 	const api = new DokployApi$1({
 		baseUrl: endpoint,
 		token
@@ -3810,6 +3810,89 @@ async function deployDokploy(options) {
 	};
 }
 
+//#endregion
+//#region src/deploy/state.ts
+/**
+* Get the state file path for a stage
+*/
+function getStateFilePath(workspaceRoot, stage) {
+	return join(workspaceRoot, ".gkm", `deploy-${stage}.json`);
+}
+/**
+* Read the deploy state for a stage
+* Returns null if state file doesn't exist
+*/
+async function readStageState(workspaceRoot, stage) {
+	const filePath = getStateFilePath(workspaceRoot, stage);
+	try {
+		const content = await readFile(filePath, "utf-8");
+		return JSON.parse(content);
+	} catch (error) {
+		if (error.code === "ENOENT") return null;
+		console.warn(`Warning: Could not read deploy state: ${error}`);
+		return null;
+	}
+}
+/**
+* Write the deploy state for a stage
+*/
+async function writeStageState(workspaceRoot, stage, state) {
+	const filePath = getStateFilePath(workspaceRoot, stage);
+	const dir = join(workspaceRoot, ".gkm");
+	await mkdir(dir, { recursive: true });
+	state.lastDeployedAt = (/* @__PURE__ */ new Date()).toISOString();
+	await writeFile(filePath, JSON.stringify(state, null, 2));
+}
+/**
+* Create a new empty state for a stage
+*/
+function createEmptyState(stage, environmentId) {
+	return {
+		provider: "dokploy",
+		stage,
+		environmentId,
+		applications: {},
+		services: {},
+		lastDeployedAt: (/* @__PURE__ */ new Date()).toISOString()
+	};
+}
+/**
+* Get application ID from state
+*/
+function getApplicationId(state, appName) {
+	return state?.applications[appName];
+}
+/**
+* Set application ID in state (mutates state)
+*/
+function setApplicationId(state, appName, applicationId) {
+	state.applications[appName] = applicationId;
+}
+/**
+* Get postgres ID from state
+*/
+function getPostgresId(state) {
+	return state?.services.postgresId;
+}
+/**
+* Set postgres ID in state (mutates state)
+*/
+function setPostgresId(state, postgresId) {
+	state.services.postgresId = postgresId;
+}
+/**
+* Get redis ID from state
+*/
+function getRedisId(state) {
+	return state?.services.redisId;
+}
+/**
+* Set redis ID in state (mutates state)
+*/
+function setRedisId(state, redisId) {
+	state.services.redisId = redisId;
+}
+
 //#endregion
 //#region src/deploy/domain.ts
 /**
@@ -4314,24 +4397,39 @@ async function prompt(message, hidden = false) {
 * Provision docker compose services in Dokploy
 * @internal Exported for testing
 */
-async function provisionServices(api, projectId, environmentId, appName, services, existingUrls) {
+async function provisionServices(api, projectId, environmentId, appName, services, existingServiceIds) {
 	logger$1.log(`\n🔍 provisionServices called: services=${JSON.stringify(services)}, envId=${environmentId}`);
 	if (!services || !environmentId) {
 		logger$1.log("   Skipping: no services or no environmentId");
 		return void 0;
 	}
 	const serviceUrls = {};
-	if (services.postgres) if (existingUrls?.DATABASE_URL) logger$1.log("\n🐘 PostgreSQL: Already configured (skipping)");
-	else {
-		logger$1.log("\n🐘 Provisioning PostgreSQL...");
-		const postgresName = `${appName}-db`;
+	const serviceIds = {};
+	if (services.postgres) {
+		logger$1.log("\n🐘 Checking PostgreSQL...");
+		const postgresName = "db";
 		try {
-			const { randomBytes: randomBytes$1 } = await import("node:crypto");
-			const databasePassword = randomBytes$1(16).toString("hex");
-			const postgres = await api.createPostgres(postgresName, projectId, environmentId, { databasePassword });
-			logger$1.log(`   ✓ Created PostgreSQL: ${postgres.postgresId}`);
-			await api.deployPostgres(postgres.postgresId);
-			logger$1.log("   ✓ PostgreSQL deployed");
+			let postgres = null;
+			let created = false;
+			if (existingServiceIds?.postgresId) {
+				logger$1.log(`   Using cached ID: ${existingServiceIds.postgresId}`);
+				postgres = await api.getPostgres(existingServiceIds.postgresId);
+				if (postgres) logger$1.log(`   ✓ PostgreSQL found: ${postgres.postgresId}`);
+				else logger$1.log(`   ⚠ Cached ID invalid, will create new`);
+			}
+			if (!postgres) {
+				const { randomBytes: randomBytes$1 } = await import("node:crypto");
+				const databasePassword = randomBytes$1(16).toString("hex");
+				const result = await api.findOrCreatePostgres(postgresName, projectId, environmentId, { databasePassword });
+				postgres = result.postgres;
+				created = result.created;
+				if (created) {
+					logger$1.log(`   ✓ Created PostgreSQL: ${postgres.postgresId}`);
+					await api.deployPostgres(postgres.postgresId);
+					logger$1.log("   ✓ PostgreSQL deployed");
+				} else logger$1.log(`   ✓ PostgreSQL already exists: ${postgres.postgresId}`);
+			}
+			serviceIds.postgresId = postgres.postgresId;
 			serviceUrls.DATABASE_HOST = postgres.appName;
 			serviceUrls.DATABASE_PORT = "5432";
 			serviceUrls.DATABASE_NAME = postgres.databaseName;
@@ -4341,21 +4439,34 @@ async function provisionServices(api, projectId, environmentId, appName, service
 			logger$1.log(`   ✓ Database credentials configured`);
 		} catch (error) {
 			const message = error instanceof Error ? error.message : "Unknown error";
-			if (message.includes("already exists") || message.includes("duplicate")) logger$1.log(`   ℹ PostgreSQL already exists`);
-			else logger$1.log(`   ⚠ Failed to provision PostgreSQL: ${message}`);
+			logger$1.log(`   ⚠ Failed to provision PostgreSQL: ${message}`);
 		}
 	}
-	if (services.redis) if (existingUrls?.REDIS_URL) logger$1.log("\n🔴 Redis: Already configured (skipping)");
-	else {
-		logger$1.log("\n🔴 Provisioning Redis...");
-		const redisName = `${appName}-cache`;
+	if (services.redis) {
+		logger$1.log("\n🔴 Checking Redis...");
+		const redisName = "cache";
 		try {
-			const { randomBytes: randomBytes$1 } = await import("node:crypto");
-			const databasePassword = randomBytes$1(16).toString("hex");
-			const redis = await api.createRedis(redisName, projectId, environmentId, { databasePassword });
-			logger$1.log(`   ✓ Created Redis: ${redis.redisId}`);
-			await api.deployRedis(redis.redisId);
-			logger$1.log("   ✓ Redis deployed");
+			let redis = null;
+			let created = false;
+			if (existingServiceIds?.redisId) {
+				logger$1.log(`   Using cached ID: ${existingServiceIds.redisId}`);
+				redis = await api.getRedis(existingServiceIds.redisId);
+				if (redis) logger$1.log(`   ✓ Redis found: ${redis.redisId}`);
+				else logger$1.log(`   ⚠ Cached ID invalid, will create new`);
+			}
+			if (!redis) {
+				const { randomBytes: randomBytes$1 } = await import("node:crypto");
+				const databasePassword = randomBytes$1(16).toString("hex");
+				const result = await api.findOrCreateRedis(redisName, projectId, environmentId, { databasePassword });
+				redis = result.redis;
+				created = result.created;
+				if (created) {
+					logger$1.log(`   ✓ Created Redis: ${redis.redisId}`);
+					await api.deployRedis(redis.redisId);
+					logger$1.log("   ✓ Redis deployed");
+				} else logger$1.log(`   ✓ Redis already exists: ${redis.redisId}`);
+			}
+			serviceIds.redisId = redis.redisId;
 			serviceUrls.REDIS_HOST = redis.appName;
 			serviceUrls.REDIS_PORT = "6379";
 			if (redis.databasePassword) serviceUrls.REDIS_PASSWORD = redis.databasePassword;
@@ -4364,11 +4475,13 @@ async function provisionServices(api, projectId, environmentId, appName, service
 			logger$1.log(`   ✓ Redis credentials configured`);
 		} catch (error) {
 			const message = error instanceof Error ? error.message : "Unknown error";
-			if (message.includes("already exists") || message.includes("duplicate")) logger$1.log(`   ℹ Redis already exists`);
-			else logger$1.log(`   ⚠ Failed to provision Redis: ${message}`);
+			logger$1.log(`   ⚠ Failed to provision Redis: ${message}`);
 		}
 	}
-	return Object.keys(serviceUrls).length > 0 ? serviceUrls : void 0;
+	return Object.keys(serviceUrls).length > 0 ? {
+		serviceUrls,
+		serviceIds
+	} : void 0;
 }
 /**
 * Ensure Dokploy is fully configured, recovering/creating resources as needed
@@ -4423,7 +4536,7 @@ async function ensureDokploySetup(config$1, dockerConfig, stage, services) {
 			}
 			const environmentId$1 = environment.environmentId;
 			logger$1.log(`   Services config: ${JSON.stringify(services)}, envId: ${environmentId$1}`);
-			const serviceUrls$1 = await provisionServices(api, existingConfig.projectId, environmentId$1, dockerConfig.appName, services, existingUrls);
+			const provisionResult$1 = await provisionServices(api, existingConfig.projectId, environmentId$1, dockerConfig.appName, services, void 0);
 			return {
 				config: {
 					endpoint: existingConfig.endpoint,
@@ -4432,7 +4545,7 @@ async function ensureDokploySetup(config$1, dockerConfig, stage, services) {
 					registry: existingConfig.registry,
 					registryId: storedRegistryId ?? void 0
 				},
-				serviceUrls: serviceUrls$1
+				serviceUrls: provisionResult$1?.serviceUrls
 			};
 		} catch {
 			logger$1.log("⚠ Project not found, will recover...");
@@ -4539,10 +4652,10 @@ async function ensureDokploySetup(config$1, dockerConfig, stage, services) {
 	logger$1.log(`   Project: ${project.projectId}`);
 	logger$1.log(`   Application: ${applicationId}`);
 	if (registryId) logger$1.log(`   Registry: ${registryId}`);
-	const serviceUrls = await provisionServices(api, project.projectId, environmentId, dockerConfig.appName, services, existingUrls);
+	const provisionResult = await provisionServices(api, project.projectId, environmentId, dockerConfig.appName, services, void 0);
 	return {
 		config: dokployConfig,
-		serviceUrls
+		serviceUrls: provisionResult?.serviceUrls
 	};
 }
 /**
@@ -4661,6 +4774,18 @@ async function workspaceDeployCommand(workspace, options) {
 		} else environmentId = result.environment.environmentId;
 		logger$1.log(`   ✓ Created project: ${project.projectId}`);
 	}
+	logger$1.log("\n📋 Loading deploy state...");
+	let state = await readStageState(workspace.root, stage);
+	if (state) {
+		logger$1.log(`   Found existing state for stage "${stage}"`);
+		if (state.environmentId !== environmentId) {
+			logger$1.log(`   ⚠ Environment ID changed, updating state`);
+			state.environmentId = environmentId;
+		}
+	} else {
+		logger$1.log(`   Creating new state for stage "${stage}"`);
+		state = createEmptyState(stage, environmentId);
+	}
 	logger$1.log("\n🐳 Checking registry...");
 	let registryId = await getDokployRegistryId();
 	const registry = workspace.deploy.dokploy?.registry;
@@ -4696,7 +4821,15 @@ async function workspaceDeployCommand(workspace, options) {
 	};
 	if (dockerServices.postgres || dockerServices.redis) {
 		logger$1.log("\n🔧 Provisioning infrastructure services...");
-		await provisionServices(api, project.projectId, environmentId, workspace.name, dockerServices);
+		const existingServiceIds = {
+			postgresId: getPostgresId(state),
+			redisId: getRedisId(state)
+		};
+		const provisionResult = await provisionServices(api, project.projectId, environmentId, workspace.name, dockerServices, existingServiceIds);
+		if (provisionResult?.serviceIds) {
+			if (provisionResult.serviceIds.postgresId) setPostgresId(state, provisionResult.serviceIds.postgresId);
+			if (provisionResult.serviceIds.redisId) setRedisId(state, provisionResult.serviceIds.redisId);
+		}
 	}
 	const backendApps = appsToDeployNames.filter((name$1) => workspace.apps[name$1].type === "backend");
 	const frontendApps = appsToDeployNames.filter((name$1) => workspace.apps[name$1].type === "frontend");
@@ -4709,16 +4842,22 @@ async function workspaceDeployCommand(workspace, options) {
 			const app = workspace.apps[appName];
 			logger$1.log(`\n   ⚙️  Deploying ${appName}...`);
 			try {
-				const dokployAppName = `${workspace.name}-${appName}`;
-				let application;
-				try {
-					application = await api.createApplication(dokployAppName, project.projectId, environmentId);
-					logger$1.log(`      Created application: ${application.applicationId}`);
-				} catch (error) {
-					const message = error instanceof Error ? error.message : "Unknown error";
-					if (message.includes("already exists") || message.includes("duplicate")) logger$1.log(`      Application already exists`);
-					else throw error;
+				const dokployAppName = appName;
+				let application = null;
+				const cachedAppId = getApplicationId(state, appName);
+				if (cachedAppId) {
+					logger$1.log(`      Using cached ID: ${cachedAppId}`);
+					application = await api.getApplication(cachedAppId);
+					if (application) logger$1.log(`      ✓ Application found: ${application.applicationId}`);
+					else logger$1.log(`      ⚠ Cached ID invalid, will create new`);
+				}
+				if (!application) {
+					const result = await api.findOrCreateApplication(dokployAppName, project.projectId, environmentId);
+					application = result.application;
+					if (result.created) logger$1.log(`      Created application: ${application.applicationId}`);
+					else logger$1.log(`      Found existing application: ${application.applicationId}`);
 				}
+				setApplicationId(state, appName, application.applicationId);
 				const appSecrets = encryptedSecrets.get(appName);
 				const buildArgs = [];
 				if (appSecrets && appSecrets.secretCount > 0) {
@@ -4742,47 +4881,35 @@ async function workspaceDeployCommand(workspace, options) {
 				});
 				const envVars = [`NODE_ENV=production`, `PORT=${app.port}`];
 				if (appSecrets && appSecrets.masterKey) envVars.push(`GKM_MASTER_KEY=${appSecrets.masterKey}`);
-				if (application) {
-					await api.saveDockerProvider(application.applicationId, imageRef, { registryId });
-					await api.saveApplicationEnv(application.applicationId, envVars.join("\n"));
-					logger$1.log(`      Deploying to Dokploy...`);
-					await api.deployApplication(application.applicationId);
-					try {
-						const host = resolveHost(appName, app, stage, dokployConfig, false);
-						await api.createDomain({
-							host,
-							port: app.port,
-							https: true,
-							certificateType: "letsencrypt",
-							applicationId: application.applicationId
-						});
-						const publicUrl = `https://${host}`;
-						publicUrls[appName] = publicUrl;
-						logger$1.log(`      ✓ Domain: ${publicUrl}`);
-					} catch (domainError) {
-						const host = resolveHost(appName, app, stage, dokployConfig, false);
-						publicUrls[appName] = `https://${host}`;
-						logger$1.log(`      ℹ Domain already configured: https://${host}`);
-					}
-					results.push({
-						appName,
-						type: app.type,
-						success: true,
-						applicationId: application.applicationId,
-						imageRef
+				await api.saveDockerProvider(application.applicationId, imageRef, { registryId });
+				await api.saveApplicationEnv(application.applicationId, envVars.join("\n"));
+				logger$1.log(`      Deploying to Dokploy...`);
+				await api.deployApplication(application.applicationId);
+				try {
+					const host = resolveHost(appName, app, stage, dokployConfig, false);
+					await api.createDomain({
+						host,
+						port: app.port,
+						https: true,
+						certificateType: "letsencrypt",
+						applicationId: application.applicationId
 					});
-					logger$1.log(`      ✓ ${appName} deployed successfully`);
-				} else {
+					const publicUrl = `https://${host}`;
+					publicUrls[appName] = publicUrl;
+					logger$1.log(`      ✓ Domain: ${publicUrl}`);
+				} catch (domainError) {
 					const host = resolveHost(appName, app, stage, dokployConfig, false);
 					publicUrls[appName] = `https://${host}`;
-					results.push({
-						appName,
-						type: app.type,
-						success: true,
-						imageRef
-					});
-					logger$1.log(`      ✓ ${appName} image pushed (app already exists)`);
+					logger$1.log(`      ℹ Domain already configured: https://${host}`);
 				}
+				results.push({
+					appName,
+					type: app.type,
+					success: true,
+					applicationId: application.applicationId,
+					imageRef
+				});
+				logger$1.log(`      ✓ ${appName} deployed successfully`);
 			} catch (error) {
 				const message = error instanceof Error ? error.message : "Unknown error";
 				logger$1.log(`      ✗ Failed to deploy ${appName}: ${message}`);
@@ -4802,16 +4929,22 @@ async function workspaceDeployCommand(workspace, options) {
 			const app = workspace.apps[appName];
 			logger$1.log(`\n   🌐 Deploying ${appName}...`);
 			try {
-				const dokployAppName = `${workspace.name}-${appName}`;
-				let application;
-				try {
-					application = await api.createApplication(dokployAppName, project.projectId, environmentId);
-					logger$1.log(`      Created application: ${application.applicationId}`);
-				} catch (error) {
-					const message = error instanceof Error ? error.message : "Unknown error";
-					if (message.includes("already exists") || message.includes("duplicate")) logger$1.log(`      Application already exists`);
-					else throw error;
+				const dokployAppName = appName;
+				let application = null;
+				const cachedAppId = getApplicationId(state, appName);
+				if (cachedAppId) {
+					logger$1.log(`      Using cached ID: ${cachedAppId}`);
+					application = await api.getApplication(cachedAppId);
+					if (application) logger$1.log(`      ✓ Application found: ${application.applicationId}`);
+					else logger$1.log(`      ⚠ Cached ID invalid, will create new`);
 				}
+				if (!application) {
+					const result = await api.findOrCreateApplication(dokployAppName, project.projectId, environmentId);
+					application = result.application;
+					if (result.created) logger$1.log(`      Created application: ${application.applicationId}`);
+					else logger$1.log(`      Found existing application: ${application.applicationId}`);
+				}
+				setApplicationId(state, appName, application.applicationId);
 				const buildArgs = generatePublicUrlBuildArgs(app, publicUrls);
 				if (buildArgs.length > 0) logger$1.log(`      Public URLs: ${buildArgs.join(", ")}`);
 				const imageName = `${workspace.name}-${appName}`;
@@ -4830,49 +4963,36 @@ async function workspaceDeployCommand(workspace, options) {
 					publicUrlArgs: getPublicUrlArgNames(app)
 				});
 				const envVars = [`NODE_ENV=production`, `PORT=${app.port}`];
-				if (application) {
-					await api.saveDockerProvider(application.applicationId, imageRef, { registryId });
-					await api.saveApplicationEnv(application.applicationId, envVars.join("\n"));
-					logger$1.log(`      Deploying to Dokploy...`);
-					await api.deployApplication(application.applicationId);
-					const isMainFrontend = isMainFrontendApp(appName, app, workspace.apps);
-					try {
-						const host = resolveHost(appName, app, stage, dokployConfig, isMainFrontend);
-						await api.createDomain({
-							host,
-							port: app.port,
-							https: true,
-							certificateType: "letsencrypt",
-							applicationId: application.applicationId
-						});
-						const publicUrl = `https://${host}`;
-						publicUrls[appName] = publicUrl;
-						logger$1.log(`      ✓ Domain: ${publicUrl}`);
-					} catch (domainError) {
-						const host = resolveHost(appName, app, stage, dokployConfig, isMainFrontend);
-						publicUrls[appName] = `https://${host}`;
-						logger$1.log(`      ℹ Domain already configured: https://${host}`);
-					}
-					results.push({
-						appName,
-						type: app.type,
-						success: true,
-						applicationId: application.applicationId,
-						imageRef
+				await api.saveDockerProvider(application.applicationId, imageRef, { registryId });
+				await api.saveApplicationEnv(application.applicationId, envVars.join("\n"));
+				logger$1.log(`      Deploying to Dokploy...`);
+				await api.deployApplication(application.applicationId);
+				const isMainFrontend = isMainFrontendApp(appName, app, workspace.apps);
+				try {
+					const host = resolveHost(appName, app, stage, dokployConfig, isMainFrontend);
+					await api.createDomain({
+						host,
+						port: app.port,
+						https: true,
+						certificateType: "letsencrypt",
+						applicationId: application.applicationId
 					});
-					logger$1.log(`      ✓ ${appName} deployed successfully`);
-				} else {
-					const isMainFrontend = isMainFrontendApp(appName, app, workspace.apps);
+					const publicUrl = `https://${host}`;
+					publicUrls[appName] = publicUrl;
+					logger$1.log(`      ✓ Domain: ${publicUrl}`);
+				} catch (domainError) {
 					const host = resolveHost(appName, app, stage, dokployConfig, isMainFrontend);
 					publicUrls[appName] = `https://${host}`;
-					results.push({
-						appName,
-						type: app.type,
-						success: true,
-						imageRef
-					});
-					logger$1.log(`      ✓ ${appName} image pushed (app already exists)`);
+					logger$1.log(`      ℹ Domain already configured: https://${host}`);
 				}
+				results.push({
+					appName,
+					type: app.type,
+					success: true,
+					applicationId: application.applicationId,
+					imageRef
+				});
+				logger$1.log(`      ✓ ${appName} deployed successfully`);
 			} catch (error) {
 				const message = error instanceof Error ? error.message : "Unknown error";
 				logger$1.log(`      ✗ Failed to deploy ${appName}: ${message}`);
@@ -4885,6 +5005,9 @@ async function workspaceDeployCommand(workspace, options) {
 			}
 		}
 	}
+	logger$1.log("\n📋 Saving deploy state...");
+	await writeStageState(workspace.root, stage, state);
+	logger$1.log(`   ✓ State saved to .gkm/deploy-${stage}.json`);
 	const successCount = results.filter((r) => r.success).length;
 	const failedCount = results.filter((r) => !r.success).length;
 	logger$1.log(`\n${"─".repeat(50)}`);