@agentuity/cli 1.0.29 → 1.0.31

package/src/cmd/cloud/task/get.ts

@@ -11,6 +11,14 @@ const EntityRefSchema = z
 	})
 	.optional();
 
+const UserEntityRefSchema = z
+	.object({
+		id: z.string(),
+		name: z.string(),
+		type: z.enum(['human', 'agent']).optional(),
+	})
+	.optional();
+
 const TaskGetResponseSchema = z.object({
 	success: z.boolean().describe('Whether the operation succeeded'),
 	task: z.object({
@@ -21,9 +29,9 @@ const TaskGetResponseSchema = z.object({
 		status: z.string().describe('Task status'),
 		priority: z.string().describe('Task priority'),
 		parent_id: z.string().optional().describe('Parent task ID'),
-		creator: EntityRefSchema.describe('Creator'),
-		assignee: EntityRefSchema.describe('Assignee'),
-		closer: EntityRefSchema.describe('Closer'),
+		creator: UserEntityRefSchema.describe('Creator'),
+		assignee: UserEntityRefSchema.describe('Assignee'),
+		closer: UserEntityRefSchema.describe('Closer'),
 		project: EntityRefSchema.describe('Project'),
 		metadata: z.record(z.string(), z.unknown()).optional().describe('Task metadata'),
 		created_at: z.string().describe('Creation timestamp'),

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

@@ -3,6 +3,7 @@ import { getSubcommand } from './get';
 import { createSubcommand } from './create';
 import { updateSubcommand } from './update';
 import { listSubcommand } from './list';
+import { deleteSubcommand } from './delete';
 import { statsSubcommand } from './stats';
 import { attachmentSubcommand } from './attachment';
 import { getCommand } from '../../../command-prefix';
@@ -28,6 +29,14 @@ export const taskCommand = createCommand({
 			command: getCommand('cloud task update task_abc123 --status in_progress'),
 			description: 'Update task status',
 		},
+		{
+			command: getCommand('cloud task delete task_abc123'),
+			description: 'Delete a task by ID',
+		},
+		{
+			command: getCommand('cloud task delete --status closed --older-than 7d'),
+			description: 'Batch delete closed tasks older than 7 days',
+		},
 		{
 			command: getCommand('cloud task attachment upload task_abc123 ./report.pdf'),
 			description: 'Upload a file attachment to a task',
@@ -38,6 +47,7 @@ export const taskCommand = createCommand({
 		createSubcommand,
 		updateSubcommand,
 		listSubcommand,
+		deleteSubcommand,
 		statsSubcommand,
 		attachmentSubcommand,
 	],

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

@@ -18,12 +18,14 @@ const TaskListResponseSchema = z.object({
 				.object({
 					id: z.string(),
 					name: z.string(),
+					type: z.enum(['human', 'agent']).optional(),
 				})
 				.optional(),
 			assignee: z
 				.object({
 					id: z.string(),
 					name: z.string(),
+					type: z.enum(['human', 'agent']).optional(),
 				})
 				.optional(),
 			project: z

package/src/cmd/project/template-flow.ts

@@ -11,6 +11,7 @@ import {
 	APIClient as ServerAPIClient,
 	createResources,
 	validateDatabaseName,
+	validateBucketName,
 } from '@agentuity/server';
 import type { Logger } from '@agentuity/core';
 import * as tui from '../../tui';
@@ -440,11 +441,40 @@ export async function runCreateFlow(options: CreateFlowOptions): Promise<CreateF
 		// Process storage action
 		switch (s3_action) {
 			case 'Create New': {
+				let bucketName: string | undefined;
+				let bucketDescription: string | undefined;
+
+				// Only prompt for name/description in interactive mode
+				if (isInteractive) {
+					const bucketNameInput = await prompt.text({
+						message: 'Bucket name',
+						hint: 'Optional - lowercase letters, digits, hyphens only',
+						validate: (value: string) => {
+							const trimmed = value.trim();
+							if (trimmed === '') return true;
+							const result = validateBucketName(trimmed);
+							return result.valid ? true : result.error!;
+						},
+					});
+					bucketName = bucketNameInput.trim() || undefined;
+					bucketDescription =
+						(await prompt.text({
+							message: 'Bucket description',
+							hint: 'Optional - press Enter to skip',
+						})) || undefined;
+				}
+
 				const created = await tui.spinner({
 					message: 'Provisioning New Bucket',
 					clearOnSuccess: true,
 					callback: async () => {
-						return createResources(catalystClient!, orgId!, region!, [{ type: 's3' }]);
+						return createResources(catalystClient!, orgId!, region!, [
+							{
+								type: 's3',
+								name: bucketName,
+								description: bucketDescription,
+							},
+						]);
 					},
 				});
 				// Collect env vars from newly created resource

package/src/domain.ts

@@ -95,6 +95,30 @@ async function fetchDNSRecord(name: string, type: string): Promise<string | null
 	return records[0] ?? null;
 }
 
+/**
+ * Check if a domain has a valid TLS certificate by making a HEAD request.
+ * This also triggers Let's Encrypt certificate provisioning on first access.
+ * Returns true if the TLS certificate is valid (any HTTP status code received).
+ * Returns false if the certificate is not yet provisioned (timeout or TLS error).
+ */
+async function checkTLSCertificate(domain: string): Promise<boolean> {
+	try {
+		await fetch(`https://${domain}`, {
+			method: 'HEAD',
+			signal: AbortSignal.timeout(timeoutMs),
+			redirect: 'manual',
+			// @ts-expect-error - cache is supported by Bun's fetch at runtime but missing from type definitions
+			cache: 'no-store',
+		});
+		// Any HTTP response means TLS handshake succeeded and certificate is valid
+		return true;
+	} catch {
+		// Timeout, TLS certificate error, connection refused, etc.
+		// All indicate the certificate is not yet provisioned
+		return false;
+	}
+}
+
 const LOCAL_DNS = 'agentuity.io';
 const PRODUCTION_DNS = 'agentuity.run';
 
@@ -171,15 +195,27 @@ export async function checkCustomDomainForDNS(
 					if (timeoutId) clearTimeout(timeoutId);
 				});
 
-				if (result) {
-					if (result === proxy) {
+			if (result) {
+				if (result === proxy) {
+						// DNS is correct — verify TLS certificate (also triggers Let's Encrypt provisioning)
+						const tlsValid = await checkTLSCertificate(domain);
+						if (tlsValid) {
+							return {
+								domain,
+								target: proxy,
+								aRecordTarget,
+								recordType: 'CNAME',
+								success: true,
+							} as DNSSuccess;
+						}
 						return {
 							domain,
 							target: proxy,
 							aRecordTarget,
 							recordType: 'CNAME',
 							success: true,
-						} as DNSSuccess;
+							pending: true,
+						} as DNSPending;
 					}
 					return {
 						domain,
@@ -242,13 +278,25 @@ export async function checkCustomDomainForDNS(
 					if (domainARecords.length > 0) {
 						const matching = domainARecords.some((a) => ionIPs.includes(a));
 						if (matching) {
+							// DNS is correct — verify TLS certificate (also triggers Let's Encrypt provisioning)
+							const tlsValid = await checkTLSCertificate(domain);
+							if (tlsValid) {
+								return {
+									domain,
+									target: proxy,
+									aRecordTarget,
+									recordType: 'A',
+									success: true,
+								} as DNSSuccess;
+							}
 							return {
 								domain,
 								target: proxy,
 								aRecordTarget,
 								recordType: 'A',
 								success: true,
-							} as DNSSuccess;
+								pending: true,
+							} as DNSPending;
 						}
 						return {
 							domain,

package/src/tui.ts

@@ -2235,7 +2235,8 @@ export function formatBytes(bytes: number): string {
 	if (bytes < 1024) return `${bytes} B`;
 	if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(2)} KB`;
 	if (bytes < 1024 * 1024 * 1024) return `${(bytes / (1024 * 1024)).toFixed(2)} MB`;
-	return `${(bytes / (1024 * 1024 * 1024)).toFixed(2)} GB`;
+	if (bytes < 1024 * 1024 * 1024 * 1024) return `${(bytes / (1024 * 1024 * 1024)).toFixed(2)} GB`;
+	return `${(bytes / (1024 * 1024 * 1024 * 1024)).toFixed(2)} TB`;
 }
 
 export function clearLastLines(n: number, s?: (v: string) => void) {