@agentuity/cli 0.0.42 → 0.0.44

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 };
+}