@agentuity/cli 1.0.9 → 1.0.11

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

@@ -12,8 +12,8 @@ const SessionListResponseSchema = z.array(
 		created_at: z.string().describe('Creation timestamp'),
 		success: z.boolean().describe('Whether the session succeeded'),
 		duration: z.number().nullable().describe('Duration in nanoseconds'),
-		method: z.string().describe('HTTP method'),
-		url: z.string().describe('Request URL'),
+		method: z.string().nullable().describe('HTTP method'),
+		url: z.string().nullable().describe('Request URL'),
 		trigger: z.string().describe('Trigger type'),
 		env: z.string().describe('Environment'),
 	})
@@ -91,6 +91,14 @@ export const listSubcommand = createSubcommand({
 			success: z.coerce.boolean().optional().describe('Filter by success status (true/false)'),
 			startAfter: z.string().optional().describe('Filter by start time after (ISO 8601)'),
 			startBefore: z.string().optional().describe('Filter by start time before (ISO 8601)'),
+			sort: z
+				.enum(['created', 'updated', 'duration', 'startTime'])
+				.optional()
+				.describe('field to sort by (default: created)'),
+			direction: z
+				.enum(['asc', 'desc'])
+				.optional()
+				.describe('sort direction (default: desc)'),
 		}),
 		response: SessionListResponseSchema,
 	},
@@ -109,20 +117,22 @@ export const listSubcommand = createSubcommand({
 		const projectId = opts.all || opts.orgId ? undefined : opts.projectId || project?.projectId;
 
 		try {
-			const sessions = await sessionList(catalystClient, {
-				count: opts.count,
-				orgId: opts?.orgId,
-				projectId,
-				deploymentId: opts.deploymentId,
-				trigger: opts.trigger,
-				env: opts.env,
-				devmode: opts.devmode,
-				success: opts.success,
-				threadId: opts.threadId,
-				agentIdentifier: opts.agentIdentifier,
-				startAfter: opts.startAfter,
-				startBefore: opts.startBefore,
-			});
+		const sessions = await sessionList(catalystClient, {
+			count: opts.count,
+			orgId: opts?.orgId,
+			projectId,
+			deploymentId: opts.deploymentId,
+			trigger: opts.trigger,
+			env: opts.env,
+			devmode: opts.devmode,
+			success: opts.success,
+			threadId: opts.threadId,
+			agentIdentifier: opts.agentIdentifier,
+			startAfter: opts.startAfter,
+			startBefore: opts.startBefore,
+			sort: opts.sort,
+			direction: opts.direction,
+		});
 
 			const result = sessions.map((s) => ({
 				id: s.id,
@@ -146,13 +156,13 @@ export const listSubcommand = createSubcommand({
 			}
 
 			const tableData = sessions.map((s) => {
-				const urlPath = new URL(s.url).pathname;
+				const urlPath = s.url ? new URL(s.url).pathname : '-';
 				return {
 					ID: s.id,
 					Created: new Date(s.created_at).toLocaleString(),
 					Success: s.success ? '✓' : '✗',
 					Duration: s.duration ? `${(s.duration / 1_000_000).toFixed(0)}ms` : '-',
-					Method: s.method,
+					Method: s.method ?? '-',
 					Path: urlPath.length > 50 ? urlPath.substring(0, 47) + '...' : urlPath,
 					Trigger: s.trigger,
 					Env: s.env,

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

@@ -77,6 +77,14 @@ export const listSubcommand = createSubcommand({
 					'Show credentials in plain text (default: masked in terminal, unmasked in JSON)'
 				),
 			nameOnly: z.boolean().optional().describe('Print the name only'),
+			sort: z
+				.enum(['name', 'created'])
+				.optional()
+				.describe('field to sort by (default: created)'),
+			direction: z
+				.enum(['asc', 'desc'])
+				.optional()
+				.describe('sort direction (default: desc)'),
 		}),
 		response: StorageListResponseSchema,
 	},
@@ -95,7 +103,12 @@ export const listSubcommand = createSubcommand({
 			message: 'Fetching storage',
 			clearOnSuccess: true,
 			callback: async () => {
-				return listOrgResources(catalystClient, { type: 's3', orgId: opts?.orgId });
+				return listOrgResources(catalystClient, {
+					type: 's3',
+					orgId: opts?.orgId,
+					sort: opts?.sort,
+					direction: opts?.direction,
+				});
 			},
 		});
 

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

@@ -67,6 +67,14 @@ export const listSubcommand = createCommand({
 				.describe('filter by metadata (format: key=value or key1=value1,key2=value2)'),
 			projectId: z.string().optional().describe('filter by project ID'),
 			orgId: z.string().optional().describe('filter by organization ID'),
+			sort: z
+				.enum(['name', 'created', 'updated', 'size'])
+				.optional()
+				.describe('field to sort by (default: created)'),
+			direction: z
+				.enum(['asc', 'desc'])
+				.optional()
+				.describe('sort direction (default: desc)'),
 		}),
 		response: ListStreamsResponseSchema,
 	},
@@ -120,14 +128,16 @@ export const listSubcommand = createCommand({
 		}
 
 		try {
-			const result = await streamList(apiClient, {
-				limit: opts.size,
-				offset: opts.offset,
-				namespace: opts.namespace,
-				metadata: metadataFilter,
-				projectId,
-				orgId: opts.orgId,
-			});
+		const result = await streamList(apiClient, {
+			limit: opts.size,
+			offset: opts.offset,
+			namespace: opts.namespace,
+			metadata: metadataFilter,
+			projectId,
+			orgId: opts.orgId,
+			sort: opts.sort,
+			direction: opts.direction,
+		});
 
 			if (options.json) {
 				console.log(JSON.stringify(result, null, 2));

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

@@ -63,6 +63,14 @@ export const listSubcommand = createSubcommand({
 			orgId: z.string().optional().describe('Filter by organization ID'),
 			projectId: z.string().optional().describe('Filter by project ID'),
 			all: z.boolean().optional().describe('List all threads regardless of project context'),
+			sort: z
+				.enum(['created', 'updated'])
+				.optional()
+				.describe('field to sort by (default: created)'),
+			direction: z
+				.enum(['asc', 'desc'])
+				.optional()
+				.describe('sort direction (default: desc)'),
 		}),
 		response: ThreadListResponseSchema,
 	},
@@ -78,11 +86,13 @@ export const listSubcommand = createSubcommand({
 		const orgId = opts.orgId;
 
 		try {
-			const threads = await threadList(catalystClient, {
-				count: opts.count,
-				orgId,
-				projectId,
-			});
+		const threads = await threadList(catalystClient, {
+			count: opts.count,
+			orgId,
+			projectId,
+			sort: opts.sort,
+			direction: opts.direction,
+		});
 
 			const result = threads.map((t: Thread) => ({
 				id: t.id,

package/src/cmd/dev/download.ts

@@ -1,118 +1,116 @@
 import { randomUUID } from 'node:crypto';
-import { existsSync, createReadStream, mkdirSync, rmSync } from 'node:fs';
+import { mkdirSync, rmSync, writeFileSync } 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 { StructuredError } from '@agentuity/core';
 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;
 }
 
+const GravityVersionError = StructuredError('GravityVersionError')<{
+	status: number;
+	statusText: string;
+}>();
+const GravityDownloadError = StructuredError('GravityDownloadError')<{
+	status: number;
+	statusText: string;
+}>();
+const GravityExtractionError = StructuredError('GravityExtractionError')<{
+	path: string;
+}>();
+
+function getBaseURL(): string {
+	return process.env.AGENTUITY_SH_URL || 'https://agentuity.sh';
+}
+
 /**
  *
  * @returns full path to the downloaded file
  */
 export async function download(gravityDir: string): Promise<GravityClient> {
-	const outputdir = join(tmpdir(), randomUUID());
+	const baseURL = getBaseURL();
 
-	const res = (await spinner({
+	// Step 1: Get the latest version from agentuity.sh
+	const tag = (await spinner({
 		message: 'Checking Agentuity Gravity',
 		callback: async () => {
-			return downloadRelease(
-				user,
-				repo,
-				outputdir,
-				filterRelease,
-				filterAsset,
-				false,
-				true,
-				true,
-				''
-			);
+			const resp = await fetch(`${baseURL}/release/gravity/version`, {
+				signal: AbortSignal.timeout(10_000),
+			});
+			if (!resp.ok) {
+				throw new GravityVersionError({
+					status: resp.status,
+					statusText: resp.statusText,
+				});
+			}
+			const text = (await resp.text()).trim();
+			return text.startsWith('v') ? text : `v${text}`;
 		},
 		clearOnSuccess: true,
-	})) as { release: string; assetFileNames: string[] };
+	})) as string;
 
-	const versionTok = res.release.split('@');
-	const version = versionTok[1] ?? 'unknown';
+	const version = tag.startsWith('v') ? tag.slice(1) : tag;
 	const releaseFilename = join(gravityDir, version, 'gravity');
-	const mustDownload = !existsSync(releaseFilename);
 
-	if (!mustDownload) {
+	// Step 2: Check if already downloaded
+	if (await Bun.file(releaseFilename).exists()) {
 		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[];
-			const file = res[0];
-			if (!file) {
-				throw new Error('No file downloaded from release');
-			}
-			return file;
-		},
-		clearOnSuccess: true,
-	});
+	// Step 3: Download the binary from agentuity.sh
+	const os = platform();
+	let arch: string = process.arch;
+	if (arch === 'x64') {
+		arch = 'x86_64';
+	}
 
-	if (downloadedFile.endsWith('.tar.gz')) {
+	const tmpFile = join(tmpdir(), `${randomUUID()}.tar.gz`);
+
+	try {
 		await spinner({
-			message: 'Extracting release',
+			message: `Downloading Gravity ${version}`,
 			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 }));
+				const resp = await fetch(`${baseURL}/release/gravity/${tag}/${os}/${arch}`, {
+					signal: AbortSignal.timeout(60_000),
 				});
+				if (!resp.ok) {
+					throw new GravityDownloadError({
+						status: resp.status,
+						statusText: resp.statusText,
+					});
+				}
+				const buffer = await resp.arrayBuffer();
+				writeFileSync(tmpFile, Buffer.from(buffer));
 			},
 			clearOnSuccess: true,
 		});
-	} else {
-		// TODO:
-	}
 
-	if (existsSync(outputdir)) {
-		rmSync(outputdir, { recursive: true });
+		// Step 4: Extract the tarball
+		await spinner({
+			message: 'Extracting release',
+			callback: async () => {
+				const downloadDir = dirname(releaseFilename);
+				if (!(await Bun.file(downloadDir).exists())) {
+					mkdirSync(downloadDir, { recursive: true });
+				}
+				await tar.x({ file: tmpFile, cwd: downloadDir, chmod: true });
+			},
+			clearOnSuccess: true,
+		});
+	} finally {
+		// Clean up temp file regardless of success or failure
+		if (await Bun.file(tmpFile).exists()) {
+			rmSync(tmpFile);
+		}
 	}
 
-	if (!existsSync(releaseFilename)) {
-		throw new Error(`Failed to extract gravity binary to ${releaseFilename}`);
+	// Step 5: Verify the binary was extracted
+	if (!(await Bun.file(releaseFilename).exists())) {
+		throw new GravityExtractionError({ path: releaseFilename });
 	}
 
 	return { filename: releaseFilename, version };

package/src/cmd/project/domain/check.ts

@@ -0,0 +1,146 @@
+import { z } from 'zod';
+import { createSubcommand } from '../../../types';
+import * as tui from '../../../tui';
+import { getCommand } from '../../../command-prefix';
+import { loadProjectConfig } from '../../../config';
+import { isJSONMode } from '../../../output';
+import {
+	checkCustomDomainForDNS,
+	isSuccess,
+	isPending,
+	isMissing,
+	isMisconfigured,
+	isError,
+} from '../../../domain';
+
+export const checkSubcommand = createSubcommand({
+	name: 'check',
+	description: 'Check DNS configuration for custom domains',
+	tags: ['read-only', 'slow', 'requires-auth', 'requires-project'],
+	requires: { auth: true, project: true },
+	idempotent: true,
+	examples: [
+		{
+			command: getCommand('project domain check'),
+			description: 'Check all configured domains',
+		},
+		{
+			command: getCommand('project domain check --domain example.com'),
+			description: 'Check a specific domain',
+		},
+	],
+	schema: {
+		options: z.object({
+			domain: z.string().optional().describe('Specific domain to check'),
+		}),
+		response: z.object({
+			domains: z.array(
+				z.object({
+					domain: z.string(),
+					recordType: z.string(),
+					target: z.string(),
+					status: z.string(),
+					success: z.boolean(),
+				})
+			),
+		}),
+	},
+
+	async handler(ctx) {
+		const { opts, options, projectDir, config, project } = ctx;
+		const jsonMode = isJSONMode(options);
+
+		// Determine which domains to check
+		let domainsToCheck: string[];
+
+		if (opts?.domain) {
+			domainsToCheck = [opts.domain.toLowerCase().trim()];
+		} else {
+			const projectConfig = await loadProjectConfig(projectDir, config);
+			domainsToCheck = projectConfig.deployment?.domains ?? [];
+		}
+
+		if (domainsToCheck.length === 0) {
+			if (!jsonMode) {
+				tui.info('No custom domains configured for this project');
+				tui.info(`Use ${tui.bold(getCommand('project add domain <domain>'))} to add one`);
+			}
+			return { domains: [] };
+		}
+
+		const results = jsonMode
+			? await checkCustomDomainForDNS(project.projectId, domainsToCheck, config)
+			: await tui.spinner({
+					message: `Checking DNS for ${domainsToCheck.length} ${tui.plural(domainsToCheck.length, 'domain', 'domains')}`,
+					clearOnSuccess: true,
+					callback: () => checkCustomDomainForDNS(project.projectId, domainsToCheck, config),
+				});
+
+		const domainResults = results.map((r) => {
+			let status: string;
+			let statusRaw: string;
+			let success = false;
+
+			if (isSuccess(r)) {
+				status = tui.colorSuccess(`${tui.ICONS.success} Configured`);
+				statusRaw = 'configured';
+				success = true;
+			} else if (isPending(r)) {
+				status = tui.colorWarning('⏳ Pending');
+				statusRaw = 'pending';
+			} else if (isMisconfigured(r)) {
+				status = tui.colorWarning(`${tui.ICONS.warning} ${r.misconfigured}`);
+				statusRaw = 'misconfigured';
+			} else if (isError(r)) {
+				status = tui.colorError(`${tui.ICONS.error} ${r.error}`);
+				statusRaw = 'error';
+			} else if (isMissing(r)) {
+				status = tui.colorError(`${tui.ICONS.error} Missing`);
+				statusRaw = 'missing';
+			} else {
+				status = tui.colorError(`${tui.ICONS.error} Unknown`);
+				statusRaw = 'unknown';
+			}
+
+			return {
+				domain: r.domain,
+				recordType: r.recordType,
+				target: r.target,
+				status,
+				statusRaw,
+				success,
+			};
+		});
+
+		if (!jsonMode) {
+			tui.newline();
+			for (const r of domainResults) {
+				console.log(`  ${tui.colorInfo('Domain:')}  ${tui.colorPrimary(r.domain)}`);
+				console.log(`  ${tui.colorInfo('Type:')}    ${tui.colorPrimary(r.recordType)}`);
+				console.log(`  ${tui.colorInfo('Target:')}  ${tui.colorPrimary(r.target)}`);
+				console.log(`  ${tui.colorInfo('Status:')}  ${r.status}`);
+				console.log();
+			}
+
+			const allGood = domainResults.every((r) => r.success);
+			if (allGood) {
+				tui.success('All domains are correctly configured');
+			} else {
+				const failCount = domainResults.filter((r) => !r.success).length;
+				tui.warning(
+					`${failCount} ${tui.plural(failCount, 'domain has', 'domains have')} DNS issues — add a CNAME record pointing to the target shown above`
+				);
+			}
+		}
+
+		return {
+			domains: domainResults.map((r) => ({
+				domain: r.domain,
+				recordType: r.recordType,
+				target: r.target,
+				status: r.statusRaw,
+				success: r.success,
+			})),
+		};
+	},
+});

package/src/cmd/project/domain/index.ts

@@ -0,0 +1,20 @@
+import { createCommand } from '../../../types';
+import { checkSubcommand } from './check';
+import { getCommand } from '../../../command-prefix';
+
+export const domainCommand = createCommand({
+	name: 'domain',
+	description: 'Manage custom domains for the project',
+	tags: ['fast', 'requires-auth'],
+	examples: [
+		{
+			command: getCommand('project domain check'),
+			description: 'Check DNS for all custom domains',
+		},
+		{
+			command: getCommand('project domain check --domain example.com'),
+			description: 'Check DNS for a specific domain',
+		},
+	],
+	subcommands: [checkSubcommand],
+});

package/src/cmd/project/hostname/get.ts

@@ -0,0 +1,54 @@
+import { z } from 'zod';
+import { createSubcommand } from '../../../types';
+import * as tui from '../../../tui';
+import { projectHostnameGet } from '@agentuity/server';
+import { getCommand } from '../../../command-prefix';
+import { isJSONMode } from '../../../output';
+
+const HostnameGetResponseSchema = z.object({
+	hostname: z.string().nullable().describe('The vanity hostname'),
+	url: z.string().nullable().describe('The full URL'),
+});
+
+export const getSubcommand = createSubcommand({
+	name: 'get',
+	description: 'Show the current vanity hostname for the project',
+	tags: ['read-only', 'fast', 'requires-auth', 'requires-project'],
+	requires: { auth: true, apiClient: true, project: true },
+	idempotent: true,
+	examples: [
+		{
+			command: getCommand('project hostname get'),
+			description: 'Show current hostname',
+		},
+	],
+	schema: {
+		response: HostnameGetResponseSchema,
+	},
+
+	async handler(ctx) {
+		const { apiClient, project, options } = ctx;
+		const jsonMode = isJSONMode(options);
+
+		const result = jsonMode
+			? await projectHostnameGet(apiClient, { projectId: project.projectId })
+			: await tui.spinner('Fetching hostname', () => {
+					return projectHostnameGet(apiClient, { projectId: project.projectId });
+				});
+
+		if (!jsonMode) {
+			if (result.hostname) {
+				tui.success(`Hostname: ${tui.bold(result.hostname)}`);
+				tui.info(`URL: ${result.url}`);
+			} else {
+				tui.info('No vanity hostname set for this project');
+				tui.info(`Use ${tui.bold(getCommand('project hostname set <hostname>'))} to set one`);
+			}
+		}
+
+		return {
+			hostname: result.hostname,
+			url: result.url,
+		};
+	},
+});

package/src/cmd/project/hostname/index.ts

@@ -0,0 +1,18 @@
+import { createCommand } from '../../../types';
+import { getSubcommand } from './get';
+import { setSubcommand } from './set';
+import { getCommand } from '../../../command-prefix';
+
+export const hostnameCommand = createCommand({
+	name: 'hostname',
+	description: 'Manage the project vanity hostname on agentuity.run',
+	tags: ['fast', 'requires-auth'],
+	examples: [
+		{ command: getCommand('project hostname get'), description: 'Show current hostname' },
+		{
+			command: getCommand('project hostname set my-cool-api'),
+			description: 'Set a custom hostname',
+		},
+	],
+	subcommands: [getSubcommand, setSubcommand],
+});