@agentuity/cli 1.0.10 → 1.0.11

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

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

@@ -0,0 +1,123 @@
+import { z } from 'zod';
+import { createSubcommand } from '../../../types';
+import * as tui from '../../../tui';
+import { projectHostnameSet } from '@agentuity/server';
+import { getCommand } from '../../../command-prefix';
+import { isJSONMode } from '../../../output';
+import { ErrorCode } from '../../../errors';
+
+// Client-side reserved names list (mirrors server-side list)
+const RESERVED_NAMES = new Set([
+	'app',
+	'api',
+	'catalyst',
+	'pulse',
+	'streams',
+	'registry',
+	'ion',
+	'status',
+	'admin',
+	'www',
+	'mail',
+	'dns',
+	'console',
+	'dashboard',
+	'docs',
+	'help',
+	'support',
+	'billing',
+	'test',
+	'staging',
+	'dev',
+	'prod',
+	'ns0',
+	'ns1',
+	'ns2',
+]);
+
+const HostnameSetResponseSchema = z.object({
+	hostname: z.string().describe('The vanity hostname that was set'),
+	url: z.string().describe('The full URL'),
+});
+
+export const setSubcommand = createSubcommand({
+	name: 'set',
+	description: 'Set a custom vanity hostname for the project on agentuity.run',
+	tags: ['mutating', 'fast', 'requires-auth', 'requires-project'],
+	requires: { auth: true, apiClient: true, project: true },
+	examples: [
+		{
+			command: getCommand('project hostname set my-cool-api'),
+			description: 'Set a custom hostname',
+		},
+	],
+	schema: {
+		args: z.object({
+			hostname: z.string().describe('the vanity hostname (e.g., my-cool-api)'),
+		}),
+		response: HostnameSetResponseSchema,
+	},
+
+	async handler(ctx) {
+		const { args, apiClient, project, options, logger } = ctx;
+		const jsonMode = isJSONMode(options);
+
+		const hostname = args.hostname.toLowerCase().trim();
+
+		// Client-side validation: DNS label regex
+		const hostnameRegex = /^[a-z0-9]([a-z0-9-]*[a-z0-9])?$/;
+		if (!hostnameRegex.test(hostname)) {
+			logger.fatal(
+				'Invalid hostname: must contain only lowercase letters, numbers, and hyphens, and must start and end with a letter or number',
+				ErrorCode.VALIDATION_FAILED
+			);
+		}
+
+		// Max 63 chars (DNS label limit)
+		if (hostname.length > 63) {
+			logger.fatal(
+				'Invalid hostname: must be 63 characters or fewer',
+				ErrorCode.VALIDATION_FAILED
+			);
+		}
+
+		// Must not match reserved hash patterns
+		const reservedHashPattern = /^[dp][a-f0-9]{16}$/;
+		if (reservedHashPattern.test(hostname)) {
+			logger.fatal(
+				'Invalid hostname: this pattern is reserved for internal use',
+				ErrorCode.VALIDATION_FAILED
+			);
+		}
+
+		// Must not be a reserved name
+		if (RESERVED_NAMES.has(hostname)) {
+			logger.fatal(
+				`Invalid hostname: "${hostname}" is a reserved name`,
+				ErrorCode.VALIDATION_FAILED
+			);
+		}
+
+		const result = jsonMode
+			? await projectHostnameSet(apiClient, {
+					projectId: project.projectId,
+					hostname,
+				})
+			: await tui.spinner('Setting hostname', () => {
+					return projectHostnameSet(apiClient, {
+						projectId: project.projectId,
+						hostname,
+					});
+				});
+
+		if (!jsonMode) {
+			tui.success(`Hostname set: ${tui.bold(result.url)}`);
+			tui.info('Hostname will be active after next deployment');
+		}
+
+		return {
+			hostname: result.hostname,
+			url: result.url,
+		};
+	},
+});

package/src/cmd/project/index.ts

@@ -6,6 +6,8 @@ import { deleteSubcommand } from './delete';
 import { showSubcommand } from './show';
 import { authCommand } from './auth';
 import { addCommand } from './add';
+import { hostnameCommand } from './hostname';
+import { domainCommand } from './domain';
 import { getCommand } from '../../command-prefix';
 
 export const command = createCommand({
@@ -22,6 +24,14 @@ export const command = createCommand({
 			command: getCommand('project add storage'),
 			description: 'Link an existing storage bucket',
 		},
+		{
+			command: getCommand('project hostname get'),
+			description: 'Show current vanity hostname',
+		},
+		{
+			command: getCommand('project domain check'),
+			description: 'Check DNS for custom domains',
+		},
 	],
 	subcommands: [
 		createProjectSubcommand,
@@ -31,5 +41,7 @@ export const command = createCommand({
 		showSubcommand,
 		authCommand,
 		addCommand,
+		hostnameCommand,
+		domainCommand,
 	],
 });

package/src/index.ts

@@ -102,7 +102,7 @@ export {
 	type CommandHandler,
 	type TableColumn,
 } from './repl';
-export { runSteps, stepSuccess, stepSkipped, stepError } from './steps';
+export { runSteps, stepSuccess, stepSkipped, stepError, StepInterruptError } from './steps';
 export { playSound } from './sound';
 export {
 	downloadWithProgress,