@agentuity/cli 0.0.43 → 0.0.44

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();
+				}
+			}
+		}
+	},
+});

package/src/cmd/cloud/scp/download.ts

@@ -0,0 +1,59 @@
+import { z } from 'zod';
+import { createSubcommand } from '../../../types';
+import * as tui from '../../../tui';
+import { getIONHost } from '../../../config';
+
+const args = z.object({
+	source: z.string().describe('the source file'),
+	destination: z.string().optional().describe('the destination file'),
+});
+
+const options = z.object({
+	identifier: z.string().optional().describe('The project or deployment id to use'),
+});
+
+export const downloadCommand = createSubcommand({
+	name: 'download',
+	aliases: ['get'],
+	description: 'Download a file using security copy',
+	requires: { apiClient: true, auth: true },
+	optional: { project: true },
+	schema: { args, options },
+
+	async handler(ctx) {
+		const { apiClient, args, opts, project, projectDir, config } = ctx;
+
+		let identifier = opts?.identifier ?? project?.projectId;
+
+		if (!identifier) {
+			identifier = await tui.showProjectList(apiClient, true);
+		}
+
+		const hostname = getIONHost(config);
+		const destination = args.destination ?? projectDir;
+
+		try {
+			const spawn = Bun.spawn({
+				cmd: ['scp', `${identifier}@${hostname}:${args.source}`, destination],
+				cwd: projectDir,
+				stdout: 'inherit',
+				stderr: 'inherit',
+				stdin: 'inherit',
+			});
+
+			await spawn.exited;
+
+			if (spawn.exitCode !== 0) {
+				tui.error(
+					`SCP download failed: ${identifier}@${hostname}:${args.source} -> ${destination} (exit code: ${spawn.exitCode})`
+				);
+				process.exit(spawn.exitCode ?? 1);
+			}
+		} catch (error) {
+			tui.error(
+				`SCP download error: ${error instanceof Error ? error.message : 'Unknown error'}`
+			);
+			process.exit(1);
+		}
+		},
+});

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

@@ -0,0 +1,9 @@
+import type { SubcommandDefinition } from '../../../types';
+import { downloadCommand } from './download';
+import { uploadCommand } from './upload';
+
+export const scpSubcommand: SubcommandDefinition = {
+	name: 'scp',
+	description: 'Secure Copy commands',
+	subcommands: [downloadCommand, uploadCommand],
+};

package/src/cmd/cloud/scp/upload.ts

@@ -0,0 +1,62 @@
+import { z } from 'zod';
+import { createSubcommand } from '../../../types';
+import * as tui from '../../../tui';
+import { getIONHost } from '../../../config';
+
+const args = z.object({
+	source: z.string().describe('the source file'),
+	destination: z
+		.string()
+		.optional()
+		.describe('the destination file (defaults to . for current directory on remote)'),
+});
+
+const options = z.object({
+	identifier: z.string().optional().describe('The project or deployment id to use'),
+});
+
+export const uploadCommand = createSubcommand({
+	name: 'upload',
+	aliases: ['cp', 'put'],
+	description: 'Upload a file using security copy',
+	requires: { apiClient: true, auth: true },
+	schema: { args, options },
+	optional: { project: true },
+
+	async handler(ctx) {
+		const { apiClient, args, opts, project, projectDir, config } = ctx;
+
+		let identifier = opts?.identifier ?? project?.projectId;
+
+		if (!identifier) {
+			identifier = await tui.showProjectList(apiClient, true);
+		}
+
+		const hostname = getIONHost(config);
+		const destination = args.destination ?? '.';
+
+		try {
+			const spawn = Bun.spawn({
+				cmd: ['scp', args.source, `${identifier}@${hostname}:${destination}`],
+				cwd: projectDir,
+				stdout: 'inherit',
+				stderr: 'inherit',
+				stdin: 'inherit',
+			});
+
+			await spawn.exited;
+
+			if (spawn.exitCode !== 0) {
+				tui.error(
+					`SCP upload failed: ${args.source} -> ${identifier}@${hostname}:${destination} (exit code: ${spawn.exitCode})`
+				);
+				process.exit(spawn.exitCode ?? 1);
+			}
+		} catch (error) {
+			tui.error(
+				`SCP upload error: ${error instanceof Error ? error.message : 'Unknown error'}`
+			);
+			process.exit(1);
+		}
+		},
+});

package/src/cmd/cloud/ssh.ts

@@ -0,0 +1,68 @@
+import { z } from 'zod';
+import { createSubcommand } from '../../types';
+import * as tui from '../../tui';
+import { getIONHost } from '../../config';
+
+const args = z.object({
+	identifier: z.string().optional().describe('The project or deployment id to use'),
+	command: z.string().optional().describe('The command to run'),
+});
+
+const options = z.object({
+	show: z.boolean().optional().describe('Show the command and exit'),
+});
+
+export const sshSubcommand = createSubcommand({
+	name: 'ssh',
+	description: 'SSH into a cloud project',
+	toplevel: true,
+	requires: { auth: true, apiClient: true },
+	optional: { project: true },
+	schema: { args, options },
+
+	async handler(ctx) {
+		const { apiClient, project, projectDir, args, config, opts } = ctx;
+
+		let projectId = project?.projectId;
+		let identifier = args?.identifier;
+		let command = args?.command;
+
+		if (!(identifier?.startsWith('proj_') || identifier?.startsWith('deploy_'))) {
+			command = identifier;
+			identifier = undefined;
+		}
+
+		if (!projectId && !identifier) {
+			projectId = await tui.showProjectList(apiClient, true);
+		}
+
+		const hostname = getIONHost(config);
+
+		const cmd = ['ssh', `${identifier ?? projectId}@${hostname}`, command].filter(
+			Boolean
+		) as string[];
+
+		// if show is passed, just show the SSH command and exit
+		if (opts?.show) {
+			if (command) {
+				// if we have a command we want to show it quoted
+				console.log(cmd[0], cmd[1], `'${cmd.slice(2).join(' ')}'`);
+			} else {
+				console.log(cmd.join(' '));
+			}
+			process.exit(0);
+		}
+
+		const spawn = Bun.spawn({
+			cmd,
+			cwd: projectDir,
+			stdout: 'inherit',
+			stderr: 'inherit',
+			stdin: 'inherit',
+		});
+
+		await spawn.exited;
+
+		process.exit(spawn.exitCode);
+	},
+});

package/src/cmd/dev/api.ts

@@ -0,0 +1,46 @@
+import { APIResponseSchema } from '@agentuity/server';
+import { z } from 'zod';
+import type { APIClient } from '../../api';
+
+const DevmodeRequestSchema = z.object({
+	hostname: z.string().optional().describe('the hostname for the endpoint'),
+});
+
+type DevmodeRequest = z.infer<typeof DevmodeRequestSchema>;
+
+const DevmodeResponseSchema = z.object({
+	id: z.string(),
+	hostname: z.string(),
+});
+export type DevmodeResponse = z.infer<typeof DevmodeResponseSchema>;
+
+const DevmodeResponseAPISchema = APIResponseSchema(DevmodeResponseSchema);
+type DevmodeResponseAPI = z.infer<typeof DevmodeResponseAPISchema>;
+
+/**
+ * Generate an Endpoint ID and Hostname
+ *
+ * @param apiClient the api client to use
+ * @param projectId the project id
+ * @param hostname the hostname is already configured
+ * @returns
+ */
+export async function generateEndpoint(
+	apiClient: APIClient,
+	projectId: string,
+	hostname?: string
+): Promise<DevmodeResponse> {
+	const resp = await apiClient.request<DevmodeResponseAPI, DevmodeRequest>(
+		'POST',
+		`/cli/devmode/2/${projectId}`,
+		DevmodeResponseAPISchema,
+		{ hostname },
+		DevmodeRequestSchema
+	);
+
+	if (!resp.success) {
+		throw new Error(resp.message);
+	}
+
+	return resp.data;
+}

package/src/cmd/dev/download.ts

@@ -0,0 +1,111 @@
+import { randomUUID } from 'node:crypto';
+import { existsSync, createReadStream, mkdirSync, rmSync } from 'node:fs';
+import { tmpdir, platform } from 'node:os';
+import { join, dirname } from 'node:path';
+import * as tar from 'tar';
+import { downloadRelease } from '@terascope/fetch-github-release';
+import { spinner } from '../../tui';
+
+const user = 'agentuity';
+const repo = 'gravity';
+
+function filterRelease(release: { prerelease: boolean }) {
+	// Filter out prereleases.
+	return release.prerelease === false;
+}
+
+function filterAsset(asset: { name: string }): boolean {
+	// Filter out the release matching our os and architecture
+	let arch: string = process.arch;
+	if (arch === 'x64') {
+		arch = 'x86_64';
+	}
+	return asset.name.includes(arch) && asset.name.includes(platform());
+}
+
+interface GravityClient {
+	filename: string;
+	version: string;
+}
+
+/**
+ *
+ * @returns full path to the downloaded file
+ */
+export async function download(gravityDir: string): Promise<GravityClient> {
+	const outputdir = join(tmpdir(), randomUUID());
+
+	const res = (await spinner({
+		message: 'Checking Agentuity Gravity',
+		callback: async () => {
+			return downloadRelease(
+				user,
+				repo,
+				outputdir,
+				filterRelease,
+				filterAsset,
+				false,
+				true,
+				true,
+				''
+			);
+		},
+		clearOnSuccess: true,
+	})) as { release: string; assetFileNames: string[] };
+
+	const versionTok = res.release.split('@');
+	const version = versionTok[1];
+	const releaseFilename = join(gravityDir, version, 'gravity');
+	const mustDownload = !existsSync(releaseFilename);
+
+	if (!mustDownload) {
+		return { filename: releaseFilename, version };
+	}
+
+	const downloadedFile = await spinner({
+		message: `Downloading Gravity ${version}`,
+		callback: async () => {
+			const res = (await downloadRelease(
+				user,
+				repo,
+				outputdir,
+				filterRelease,
+				filterAsset,
+				false,
+				true,
+				false,
+				''
+			)) as string[];
+			return res[0] as string;
+		},
+		clearOnSuccess: true,
+	});
+
+	if (downloadedFile.endsWith('.tar.gz')) {
+		await spinner({
+			message: 'Extracting release',
+			callback: async () => {
+				return new Promise<void>((resolve, reject) => {
+					const input = createReadStream(downloadedFile);
+					const downloadDir = dirname(releaseFilename);
+					if (!existsSync(downloadDir)) {
+						mkdirSync(downloadDir, { recursive: true });
+					}
+					input.on('finish', resolve);
+					input.on('end', resolve);
+					input.on('error', reject);
+					input.pipe(tar.x({ C: downloadDir, chmod: true }));
+				});
+			},
+			clearOnSuccess: true,
+		});
+	} else {
+		// TODO:
+	}
+
+	if (existsSync(outputdir)) {
+		rmSync(outputdir, { recursive: true });
+	}
+
+	return { filename: releaseFilename, version };
+}