@agentuity/cli 0.0.43 → 0.0.45

package/src/cmd/cloud/deploy.ts

@@ -1,129 +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 { z } from 'zod';
-import { join } from 'node:path';
 import * as tui from '../../tui';
-import { loadProjectConfig, saveProjectDir } from '../../config';
-import { runSteps, stepSuccess, stepSkipped, stepError } from '../../steps';
+import { saveProjectDir } from '../../config';
+import { runSteps, stepSuccess, stepSkipped, stepError, Step, ProgressCallback } from '../../steps';
 import { bundle } from '../bundle/bundler';
 import { loadBuildMetadata } from '../../config';
-import { projectEnvUpdate } from '@agentuity/server';
-import { getAPIBaseURL, APIClient } from '../../api';
+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,
-	requiresAuth: true,
-	schema: {
-		options: z.object({
-			dir: z.string().optional().describe('Directory to use for the project'),
-		}),
-	},
+	requires: { auth: true, project: true, apiClient: true },
 
 	async handler(ctx) {
-		const { opts, config } = ctx;
-		const dir = opts?.dir ?? process.cwd();
+		const { project, apiClient, projectDir, config, options } = ctx;
+
+		let deployment: Deployment | undefined;
+		let build: BuildMetadata | undefined;
+		let instructions: DeploymentInstructions | undefined;
+		let complete: DeploymentComplete | undefined;
+
 		try {
-			const project = await loadProjectConfig(dir);
-			if (!project) {
-				console.log(project); // FIXME
-			}
-			await saveProjectDir(dir);
+			await saveProjectDir(projectDir);
 
-			const apiUrl = getAPIBaseURL(config);
-			const client = new APIClient(apiUrl, config);
+			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);
 
-			await runSteps([
-				{
-					label: 'Sync Environment Variables',
-					run: async () => {
-						try {
-							// Read local env file (.env.production or .env)
-							const envFilePath = await findEnvFile(dir);
-							const localEnv = await readEnvFile(envFilePath);
+								// Filter out AGENTUITY_ keys
+								const filteredEnv = filterAgentuitySdkKeys(localEnv);
 
-							// Filter out AGENTUITY_ keys
-							const filteredEnv = filterAgentuitySdkKeys(localEnv);
+								if (Object.keys(filteredEnv).length === 0) {
+									return stepSkipped('no variables to sync');
+								}
 
-							if (Object.keys(filteredEnv).length === 0) {
-								return stepSkipped('no environment variables to sync');
-							}
+								// Split into env and secrets
+								const { env, secrets } = splitEnvAndSecrets(filteredEnv);
 
-							// 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(client, {
-								id: project.projectId,
-								env,
-								secrets,
-							});
+								// 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');
-						}
+								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 () => {
-						// TODO: implement
-						await Bun.sleep(1500);
-						return stepSuccess();
+					{
+						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');
+							}
+						},
 					},
-				},
-				{
-					label: 'Build, Verify and Package',
-					run: async () => {
-						try {
-							await bundle({
-								rootDir: dir,
-								dev: false,
+					{
+						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;
+								},
 							});
-							await loadBuildMetadata(join(dir, '.agentuity'));
+							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();
-						} catch (ex) {
-							const _ex = ex as Error;
-							return stepError(_ex.message ?? 'Error building your project');
-						}
+						},
 					},
-				},
-				{
-					label: 'Encrypt and Upload Deployment',
-					run: async () => {
-						// TODO: implement
-						await Bun.sleep(800);
-						return stepSkipped('already up to date');
-					},
-				},
-				{
-					label: 'Provision Services',
-					run: async () => {
-						// TODO: implement
-						await Bun.sleep(1200);
-						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!');
-			tui.arrow(tui.link('https://project-123455666332.agentuity.run'));
-		} catch (ex) {
-			const _ex = ex as Error;
-			if (_ex.name === 'ProjectConfigNotFoundExpection') {
-				tui.fatal(
-					`The directory ${dir} does not contain a valid Agentuity project. Missing agentuity.json`
-				);
+
+			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)
+					);
+				}
 			}
-			tui.fatal(`unxpected error trying to deploy project. ${ex}`);
+		} 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

@@ -1,8 +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],
+	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');
+		}
+	},
+});