@agentuity/cli 0.0.42 → 0.0.44

package/src/cmd/cloud/deploy.ts

@@ -0,0 +1,336 @@
+import { join, resolve } from 'node:path';
+import { createPublicKey } from 'node:crypto';
+import { createReadStream, createWriteStream } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { createSubcommand } from '../../types';
+import * as tui from '../../tui';
+import { saveProjectDir } from '../../config';
+import { runSteps, stepSuccess, stepSkipped, stepError, Step, ProgressCallback } from '../../steps';
+import { bundle } from '../bundle/bundler';
+import { loadBuildMetadata } from '../../config';
+import {
+	projectEnvUpdate,
+	projectDeploymentCreate,
+	projectDeploymentUpdate,
+	projectDeploymentComplete,
+	type Deployment,
+	type BuildMetadata,
+	type DeploymentInstructions,
+	type DeploymentComplete,
+} from '@agentuity/server';
+import {
+	findEnvFile,
+	readEnvFile,
+	filterAgentuitySdkKeys,
+	splitEnvAndSecrets,
+} from '../../env-util';
+import { zipDir } from '../../utils/zip';
+import { encryptFIPSKEMDEMStream } from '../../crypto/box';
+import { checkCustomDomainForDNS } from './domain';
+
+export const deploySubcommand = createSubcommand({
+	name: 'deploy',
+	description: 'Deploy project to the Agentuity Cloud',
+	toplevel: true,
+	requires: { auth: true, project: true, apiClient: true },
+
+	async handler(ctx) {
+		const { project, apiClient, projectDir, config, options } = ctx;
+
+		let deployment: Deployment | undefined;
+		let build: BuildMetadata | undefined;
+		let instructions: DeploymentInstructions | undefined;
+		let complete: DeploymentComplete | undefined;
+
+		try {
+			await saveProjectDir(projectDir);
+
+			await runSteps(
+				[
+					!project.deployment?.domains?.length
+						? null
+						: {
+								label: `Validate Custom Domain${project.deployment.domains.length > 1 ? `s: ${project.deployment.domains.join(', ')}` : `: ${project.deployment.domains[0]}`}`,
+								run: async () => {
+									if (project.deployment?.domains?.length) {
+										const result = await checkCustomDomainForDNS(
+											project.projectId,
+											project.deployment.domains,
+											config
+										);
+										for (const r of result) {
+											if (r.success) {
+												continue;
+											}
+											if (r.message) {
+												return stepError(r.message);
+											}
+											return stepError('unknown dns error'); // shouldn't get here
+										}
+										return stepSuccess();
+									}
+									return stepSkipped();
+								},
+							},
+					{
+						label: 'Sync Env & Secrets',
+						run: async () => {
+							try {
+								// Read local env file (.env.production or .env)
+								const envFilePath = await findEnvFile(projectDir);
+								const localEnv = await readEnvFile(envFilePath);
+
+								// Filter out AGENTUITY_ keys
+								const filteredEnv = filterAgentuitySdkKeys(localEnv);
+
+								if (Object.keys(filteredEnv).length === 0) {
+									return stepSkipped('no variables to sync');
+								}
+
+								// Split into env and secrets
+								const { env, secrets } = splitEnvAndSecrets(filteredEnv);
+
+								if (Object.keys(env).length === 0 && Object.keys(secrets).length === 0) {
+									return stepSkipped('no variables to sync');
+								}
+
+								// Push to cloud
+								await projectEnvUpdate(apiClient, {
+									id: project.projectId,
+									env,
+									secrets,
+								});
+
+								return stepSuccess();
+							} catch (ex) {
+								// Non-fatal: log warning but continue deployment
+								const _ex = ex as Error;
+								return stepSkipped(_ex.message ?? 'failed to sync env variables');
+							}
+						},
+					},
+					{
+						label: 'Create Deployment',
+						run: async () => {
+							try {
+								deployment = await projectDeploymentCreate(
+									apiClient,
+									project.projectId,
+									project.deployment
+								);
+								return stepSuccess();
+							} catch (ex) {
+								return stepError(ex instanceof Error ? ex.message : String(ex));
+							}
+						},
+					},
+					{
+						label: 'Build, Verify and Package',
+						run: async () => {
+							if (!deployment) {
+								return stepError('deployment was null');
+							}
+							try {
+								await bundle({
+									rootDir: resolve(projectDir),
+									dev: false,
+									deploymentId: deployment.id,
+									orgId: deployment.orgId,
+									projectId: project.projectId,
+									project,
+								});
+								build = await loadBuildMetadata(join(projectDir, '.agentuity'));
+								instructions = await projectDeploymentUpdate(
+									apiClient,
+									deployment.id,
+									build
+								);
+								return stepSuccess();
+							} catch (ex) {
+								const _ex = ex as Error;
+								return stepError(_ex.message ?? 'Error building your project');
+							}
+						},
+					},
+					{
+						type: 'progress',
+						label: 'Encrypt and Upload Deployment',
+						run: async (progress: ProgressCallback) => {
+							if (!deployment) {
+								return stepError('deployment was null');
+							}
+							if (!instructions) {
+								return stepError('deployment instructions were null');
+							}
+
+							progress(5);
+							ctx.logger.trace('Starting deployment zip creation');
+							// zip up the assets folder
+							const deploymentZip = join(tmpdir(), `${deployment.id}.zip`);
+							await zipDir(join(projectDir, '.agentuity'), deploymentZip, {
+								filter: (_filename: string, relative: string) => {
+									// we don't include assets in the deployment
+									if (relative.startsWith('web/assets/')) {
+										return false;
+									}
+									if (relative.startsWith('web/chunk/')) {
+										return false;
+									}
+									if (relative.startsWith('web/public/')) {
+										return false;
+									}
+									// exclude sourcemaps from deployment
+									if (relative.endsWith('.map')) {
+										return false;
+									}
+									return true;
+								},
+							});
+							ctx.logger.trace(`Deployment zip created: ${deploymentZip}`);
+
+							progress(20);
+							// Encrypt the deployment zip using the public key from deployment
+							const encryptedZip = join(tmpdir(), `${deployment.id}.enc.zip`);
+							try {
+								ctx.logger.trace('Creating public key');
+								const publicKey = createPublicKey({
+									key: deployment.publicKey,
+									format: 'pem',
+									type: 'spki',
+								});
+
+								ctx.logger.trace('Creating read/write streams');
+								const src = createReadStream(deploymentZip);
+								const dst = createWriteStream(encryptedZip);
+
+								ctx.logger.trace('Starting encryption');
+								// Wait for encryption to complete
+								await encryptFIPSKEMDEMStream(publicKey, src, dst);
+								ctx.logger.trace('Encryption complete');
+
+								progress(40);
+								ctx.logger.trace('Waiting for stream to finish');
+								// End stream and wait for it to finish writing
+								await new Promise<void>((resolve, reject) => {
+									dst.once('finish', resolve);
+									dst.once('error', reject);
+									dst.end();
+								});
+								ctx.logger.trace('Stream finished');
+
+								progress(50);
+								ctx.logger.trace(`Uploading deployment to ${instructions.deployment}`);
+								const zipfile = Bun.file(encryptedZip);
+								const fileSize = await zipfile.size;
+								ctx.logger.trace(`Upload file size: ${fileSize} bytes`);
+								const resp = await fetch(instructions.deployment, {
+									method: 'PUT',
+									duplex: 'half',
+									headers: {
+										'Content-Type': 'application/zip',
+									},
+									body: zipfile,
+								});
+								ctx.logger.trace(`Upload response: ${resp.status}`);
+								if (!resp.ok) {
+									return stepError(`Error uploading deployment: ${await resp.text()}`);
+								}
+
+								progress(70);
+								ctx.logger.trace('Consuming response body');
+								// Wait for response body to be consumed before deleting
+								await resp.arrayBuffer();
+								ctx.logger.trace('Deleting encrypted zip');
+								await zipfile.delete();
+							} finally {
+								ctx.logger.trace('Cleanup');
+								// Cleanup in case of error
+								if (await Bun.file(encryptedZip).exists()) {
+									await Bun.file(encryptedZip).delete();
+								}
+								await Bun.file(deploymentZip).delete();
+							}
+
+							progress(80);
+							if (build?.assets) {
+								ctx.logger.trace(`Uploading ${build.assets.length} assets`);
+								if (!instructions.assets) {
+									return stepError(
+										'server did not provide asset upload URLs; upload aborted'
+									);
+								}
+
+								const promises: Promise<Response>[] = [];
+								for (const asset of build.assets) {
+									const assetUrl = instructions.assets[asset.filename];
+									if (!assetUrl) {
+										return stepError(
+											`server did not provide upload URL for asset "${asset.filename}"; upload aborted`
+										);
+									}
+
+									const file = Bun.file(
+										join(projectDir, '.agentuity', 'web', asset.filename)
+									);
+									promises.push(
+										fetch(assetUrl, {
+											method: 'PUT',
+											duplex: 'half',
+											headers: {
+												'Content-Type': asset.contentType,
+											},
+											body: file,
+										})
+									);
+								}
+								ctx.logger.trace('Waiting for asset uploads');
+								const resps = await Promise.all(promises);
+								for (const r of resps) {
+									if (!r.ok) {
+										return stepError(`error uploading asset: ${await r.text()}`);
+									}
+								}
+								ctx.logger.trace('Asset uploads complete');
+								progress(95);
+							}
+
+							progress(100);
+							return stepSuccess();
+						},
+					},
+					{
+						label: 'Provision Deployment',
+						run: async () => {
+							if (!deployment) {
+								return stepError('deployment was null');
+							}
+							complete = await projectDeploymentComplete(apiClient, deployment.id);
+							return stepSuccess();
+						},
+					},
+				].filter(Boolean) as Step[],
+				options.logLevel
+			);
+			tui.success('Your project was deployed!');
+
+			if (complete?.publicUrls && deployment) {
+				tui.arrow(tui.bold(tui.padRight('Deployment ID:', 17)) + tui.link(deployment.id));
+				if (complete.publicUrls.custom?.length) {
+					for (const url of complete.publicUrls.custom) {
+						tui.arrow(tui.bold(tui.padRight('Deployment URL:', 17)) + tui.link(url));
+					}
+				} else {
+					tui.arrow(
+						tui.bold(tui.padRight('Deployment URL:', 17)) +
+							tui.link(complete.publicUrls.deployment)
+					);
+					tui.arrow(
+						tui.bold(tui.padRight('Project URL:', 17)) + tui.link(complete.publicUrls.latest)
+					);
+				}
+			}
+		} catch (ex) {
+			tui.fatal(`unexpected error trying to deploy project. ${ex}`);
+		}
+	},
+});

package/src/cmd/cloud/domain.ts

@@ -0,0 +1,92 @@
+import * as dns from 'node:dns';
+import type { Config } from '../../types';
+
+export interface DNSResult {
+	domain: string;
+	success: boolean;
+	message?: string;
+}
+
+/**
+ * This function will check for each of the custom domains and make sure they are correctly
+ * configured in DNS
+ *
+ * @param projectId the project id
+ * @param config Config
+ * @param domains array of domains to check
+ * @returns
+ */
+export async function checkCustomDomainForDNS(
+	projectId: string,
+	domains: string[],
+	config?: Config | null
+): Promise<DNSResult[]> {
+	const suffix = config?.overrides?.api_url?.includes('agentuity.io')
+		? 'agentuity.io'
+		: 'agentuity.com';
+	const id = Bun.hash.xxHash64(`${projectId}latest`).toString(16);
+	const proxy = `p${id}.${suffix}`;
+
+	return Promise.all(
+		domains.map(async (domain) => {
+			try {
+				const timeoutMs = 5000;
+				let timeoutId: Timer | undefined;
+
+				const timeoutPromise = new Promise<never>((_, reject) => {
+					timeoutId = setTimeout(() => {
+						reject(new Error(`DNS lookup timed out after ${timeoutMs}ms`));
+					}, timeoutMs);
+				});
+
+				const result = await Promise.race([
+					dns.promises.resolveCname(domain),
+					timeoutPromise,
+				]).finally(() => {
+					if (timeoutId) clearTimeout(timeoutId);
+				});
+
+				if (result.length) {
+					if (result[0] === proxy) {
+						return {
+							domain,
+							success: true,
+						};
+					}
+					return {
+						domain,
+						success: false,
+						message: `DNS record for ${domain} must have a CNAME record with the value: ${proxy}`,
+					};
+				}
+			} catch (ex) {
+				const _ex = ex as { code: string; message?: string };
+				if (_ex.message?.includes('timed out')) {
+					return {
+						domain,
+						success: false,
+						message: `DNS lookup for ${domain} timed out after 5 seconds. Please check your DNS configuration.`,
+					};
+				}
+				if (_ex.code !== 'ENOTFOUND') {
+					const errMsg =
+						ex instanceof Error
+							? ex.message
+							: typeof ex === 'string'
+								? ex
+								: JSON.stringify(ex);
+					return {
+						domain,
+						success: false,
+						message: `DNS returned an error resolving ${domain}: ${errMsg}`,
+					};
+				}
+			}
+			return {
+				domain,
+				success: false,
+				message: `To enable the custom domain ${domain}, create a CNAME DNS record with the value: ${proxy} and a TTL of 600`,
+			};
+		})
+	);
+}

package/src/cmd/cloud/index.ts

@@ -0,0 +1,11 @@
+import { createCommand } from '../../types';
+import { deploySubcommand } from './deploy';
+import { resourceSubcommand } from './resource';
+import { sshSubcommand } from './ssh';
+import { scpSubcommand } from './scp';
+
+export const command = createCommand({
+	name: 'cloud',
+	description: 'Cloud related commands',
+	subcommands: [deploySubcommand, resourceSubcommand, sshSubcommand, scpSubcommand],
+});

package/src/cmd/cloud/resource/add.ts

@@ -0,0 +1,56 @@
+import { z } from 'zod';
+import { createResources } from '@agentuity/server';
+import enquirer from 'enquirer';
+import { createSubcommand } from '../../../types';
+import * as tui from '../../../tui';
+import { getCatalystAPIClient } from '../../../config';
+
+export const addSubcommand = createSubcommand({
+	name: 'add',
+	aliases: ['create'],
+	description: 'Add a cloud resource for an organization',
+	requires: { auth: true, org: true, region: true },
+	schema: {
+		options: z.object({
+			type: z.enum(['database', 'storage']).optional().describe('Resource type'),
+		}),
+	},
+
+	async handler(ctx) {
+		const { logger, opts, orgId, region, config, auth } = ctx;
+
+		// Determine resource type
+		let resourceType = opts.type;
+		if (!resourceType) {
+			const response = await enquirer.prompt<{ type: 'database' | 'storage' }>({
+				type: 'select',
+				name: 'type',
+				message: 'Select resource type:',
+				choices: [
+					{ name: 'database', message: 'Database (PostgreSQL)' },
+					{ name: 'storage', message: 'Storage (S3)' },
+				],
+			});
+			resourceType = response.type;
+		}
+
+		// Map user-friendly type to API type
+		const apiType = resourceType === 'database' ? 'db' : 's3';
+
+		const catalystClient = getCatalystAPIClient(config, logger, auth);
+
+		const created = await tui.spinner({
+			message: `Creating ${resourceType} in ${region}`,
+			clearOnSuccess: true,
+			callback: async () => {
+				return createResources(catalystClient, orgId, region!, [{ type: apiType }]);
+			},
+		});
+
+		if (created.length > 0) {
+			tui.success(`Created ${resourceType}: ${tui.bold(created[0].name)}`);
+		} else {
+			tui.fatal('Failed to create resource');
+		}
+	},
+});

package/src/cmd/cloud/resource/delete.ts

@@ -0,0 +1,120 @@
+import { z } from 'zod';
+import { listResources, deleteResources } from '@agentuity/server';
+import enquirer from 'enquirer';
+import { createSubcommand } from '../../../types';
+import * as tui from '../../../tui';
+import { getCatalystAPIClient } from '../../../config';
+
+export const deleteSubcommand = createSubcommand({
+	name: 'delete',
+	description: 'Delete cloud resource(s) for an organization',
+	aliases: ['rm', 'del', 'remove'],
+	requires: { auth: true, org: true, region: true },
+	schema: {
+		options: z.object({
+			type: z.enum(['db', 's3']).optional().describe('Resource type (db or s3)'),
+			name: z.string().optional().describe('Resource name to delete'),
+			confirm: z.boolean().optional().describe('Skip confirmation prompts'),
+		}),
+	},
+
+	async handler(ctx) {
+		const { logger, opts, config, orgId, region, auth } = ctx;
+
+		const catalystClient = getCatalystAPIClient(config, logger, auth);
+
+		// Determine what to delete
+		let resourcesToDelete: Array<{ type: 'db' | 's3'; name: string }> = [];
+
+		if (opts.type && opts.name) {
+			// Command line arguments provided
+			resourcesToDelete = [{ type: opts.type, name: opts.name }];
+		} else {
+			// Fetch resources and prompt for selection
+			const resources = await tui.spinner({
+				message: `Fetching resources for ${orgId} in ${region}`,
+				clearOnSuccess: true,
+				callback: async () => {
+					return listResources(catalystClient, orgId, region!);
+				},
+			});
+
+			if (resources.db.length === 0 && resources.s3.length === 0) {
+				tui.info('No resources found to delete');
+				return;
+			}
+
+			// Build choices for multi-select and resource map
+			const choices: Array<{ name: string; message: string }> = [];
+			const resourceMap = new Map<string, { type: 'db' | 's3'; name: string }>();
+
+			for (const db of resources.db) {
+				const key = `db:${db.name}`;
+				choices.push({
+					name: key,
+					message: `Database: ${db.name}`,
+				});
+				resourceMap.set(key, { type: 'db', name: db.name });
+			}
+
+			for (const s3 of resources.s3) {
+				const key = `s3:${s3.bucket_name}`;
+				choices.push({
+					name: key,
+					message: `Storage: ${s3.bucket_name}`,
+				});
+				resourceMap.set(key, { type: 's3', name: s3.bucket_name });
+			}
+
+			const response = await enquirer.prompt<{ resources: string[] }>({
+				type: 'multiselect',
+				name: 'resources',
+				message: 'Select resource(s) to delete:',
+				choices,
+			});
+
+			// Map selected keys back to resource objects
+			resourcesToDelete = response.resources
+				.map((key) => resourceMap.get(key))
+				.filter((r): r is { type: 'db' | 's3'; name: string } => r !== undefined);
+		}
+
+		if (resourcesToDelete.length === 0) {
+			tui.info('No resources selected for deletion');
+			return;
+		}
+
+		// Confirm deletion
+		if (!opts.confirm) {
+			const resourceNames = resourcesToDelete.map((r) => `${r.type}:${r.name}`).join(', ');
+			tui.warning(`You are about to delete: ${tui.bold(resourceNames)}`);
+
+			const confirm = await enquirer.prompt<{ confirm: boolean }>({
+				type: 'confirm',
+				name: 'confirm',
+				message: 'Are you sure you want to delete these resources?',
+				initial: false,
+			});
+
+			if (!confirm.confirm) {
+				tui.info('Deletion cancelled');
+				return;
+			}
+		}
+
+		// Delete resources
+		const deleted = await tui.spinner({
+			message: `Deleting ${resourcesToDelete.length} resource(s)`,
+			clearOnSuccess: true,
+			callback: async () => {
+				return deleteResources(catalystClient, orgId, region!, resourcesToDelete);
+			},
+		});
+
+		if (deleted.length > 0) {
+			tui.success(`Deleted ${deleted.length} resource(s): ${deleted.join(', ')}`);
+		} else {
+			tui.error('Failed to delete resources');
+		}
+	},
+});

package/src/cmd/cloud/resource/index.ts

@@ -0,0 +1,11 @@
+import type { SubcommandDefinition } from '../../../types';
+import { listSubcommand } from './list';
+import { addSubcommand } from './add';
+import { deleteSubcommand } from './delete';
+
+export const resourceSubcommand: SubcommandDefinition = {
+	name: 'resource',
+	aliases: ['resources'],
+	description: 'Manage cloud resources',
+	subcommands: [listSubcommand, addSubcommand, deleteSubcommand],
+};

package/src/cmd/cloud/resource/list.ts

@@ -0,0 +1,69 @@
+import { z } from 'zod';
+import { listResources } from '@agentuity/server';
+import { createSubcommand } from '../../../types';
+import * as tui from '../../../tui';
+import { getCatalystAPIClient } from '../../../config';
+
+export const listSubcommand = createSubcommand({
+	name: 'list',
+	description: 'List cloud resources for an organization',
+	aliases: ['ls'],
+	requires: { auth: true, org: true, region: true },
+	schema: {
+		options: z.object({
+			format: z
+				.enum(['text', 'json'])
+				.optional()
+				.default('text')
+				.describe('Output format (text or json)'),
+		}),
+	},
+
+	async handler(ctx) {
+		const { logger, opts, orgId, region, config, auth } = ctx;
+
+		const catalystClient = getCatalystAPIClient(config, logger, auth);
+
+		const resources = await tui.spinner({
+			message: `Fetching resources for ${orgId} in ${region}`,
+			clearOnSuccess: true,
+			callback: async () => {
+				return listResources(catalystClient, orgId, region);
+			},
+		});
+
+		// Output based on format
+		if (opts.format === 'json') {
+			console.log(JSON.stringify(resources, null, 2));
+		} else {
+			// Text table format
+			if (resources.db.length === 0 && resources.s3.length === 0) {
+				tui.info('No resources found');
+				return;
+			}
+
+			if (resources.db.length > 0) {
+				tui.info(tui.bold('Databases'));
+				tui.newline();
+				for (const db of resources.db) {
+					console.log(tui.bold(db.name));
+					if (db.url) console.log(` URL:        ${tui.muted(db.url)}`);
+					tui.newline();
+				}
+			}
+
+			if (resources.s3.length > 0) {
+				tui.info(tui.bold('Storage'));
+				tui.newline();
+				for (const s3 of resources.s3) {
+					console.log(tui.bold(s3.bucket_name));
+					if (s3.access_key) console.log(` Access Key: ${tui.muted(s3.access_key)}`);
+					if (s3.secret_key) console.log(` Secret Key: ${tui.muted(s3.secret_key)}`);
+					if (s3.region) console.log(` Region:     ${tui.muted(s3.region)}`);
+					if (s3.endpoint) console.log(` Endpoint:   ${tui.muted(s3.endpoint)}`);
+					tui.newline();
+				}
+			}
+		}
+	},
+});