@agentuity/cli 1.0.0 → 1.0.2

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

@@ -1,9 +1,16 @@
 import { z } from 'zod';
+import { streamList, type StreamInfo } from '@agentuity/server';
+import { StructuredError } from '@agentuity/core';
 import { createCommand } from '../../../types';
 import * as tui from '../../../tui';
-import { createStorageAdapter } from './util';
 import { getCommand } from '../../../command-prefix';
 
+const StreamListError = StructuredError('StreamListError')<{
+	namespace?: string;
+	projectId?: string;
+	orgId?: string;
+}>();
+
 const StreamInfoSchema = z.object({
 	id: z.string().describe('Stream ID'),
 	namespace: z.string().describe('Stream namespace'),
@@ -22,7 +29,7 @@ export const listSubcommand = createCommand({
 	aliases: ['ls'],
 	description: 'List recent streams with optional filtering',
 	tags: ['read-only', 'slow', 'requires-auth'],
-	requires: { auth: true, region: true },
+	requires: { auth: true, apiClient: true },
 	optional: { project: true },
 	idempotent: true,
 	examples: [
@@ -40,6 +47,14 @@ export const listSubcommand = createCommand({
 			description: 'Filter by metadata',
 		},
 		{ command: getCommand('cloud stream ls --json'), description: 'Output as JSON' },
+		{
+			command: getCommand('cloud stream list --project-id proj_123'),
+			description: 'Filter by project',
+		},
+		{
+			command: getCommand('cloud stream list --org-id org_123'),
+			description: 'Filter by organization',
+		},
 	],
 	schema: {
 		options: z.object({
@@ -50,14 +65,17 @@ export const listSubcommand = createCommand({
 				.string()
 				.optional()
 				.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'),
 		}),
 		response: ListStreamsResponseSchema,
 	},
 	webUrl: '/services/stream',
 
 	async handler(ctx) {
-		const { opts, options } = ctx;
-		const storage = await createStorageAdapter(ctx);
+		const { opts, options, apiClient, project } = ctx;
+		// Use project context if available, or explicit flag
+		const projectId = opts.projectId || project?.projectId;
 
 		// Parse metadata filter if provided
 		let metadataFilter: Record<string, string> | undefined;
@@ -96,53 +114,67 @@ export const listSubcommand = createCommand({
 			}
 		}
 
-		const result = await storage.list({
-			limit: opts.size,
-			offset: opts.offset,
-			namespace: opts.namespace,
-			metadata: metadataFilter,
-		});
+		try {
+			const result = await streamList(apiClient, {
+				limit: opts.size,
+				offset: opts.offset,
+				namespace: opts.namespace,
+				metadata: metadataFilter,
+				projectId,
+				orgId: opts.orgId,
+			});
+
+			if (options.json) {
+				console.log(JSON.stringify(result, null, 2));
+				return {
+					streams: result.streams,
+					total: result.total,
+				};
+			}
+
+			if (result.streams.length === 0) {
+				tui.info('No streams found');
+			} else {
+				const tableData = result.streams.map((stream: StreamInfo) => {
+					const sizeBytes = stream.sizeBytes ?? 0;
+					const metadataStr =
+						Object.keys(stream.metadata).length > 0 ? JSON.stringify(stream.metadata) : '-';
+					return {
+						Namespace: stream.namespace,
+						ID: stream.id,
+						Size: tui.formatBytes(sizeBytes),
+						Metadata:
+							metadataStr.length > 40 ? metadataStr.substring(0, 37) + '...' : metadataStr,
+						URL: tui.link(stream.url),
+					};
+				});
+
+				tui.table(tableData, [
+					{ name: 'Namespace', alignment: 'left' },
+					{ name: 'ID', alignment: 'left' },
+					{ name: 'Size', alignment: 'right' },
+					{ name: 'Metadata', alignment: 'left' },
+					{ name: 'URL', alignment: 'left' },
+				]);
+
+				tui.info(`Total: ${result.total} ${tui.plural(result.total, 'stream', 'streams')}`);
+			}
 
-		if (options.json) {
-			console.log(JSON.stringify(result, null, 2));
 			return {
 				streams: result.streams,
 				total: result.total,
 			};
-		}
-
-		if (result.streams.length === 0) {
-			tui.info('No streams found');
-		} else {
-			const tableData = result.streams.map((stream) => {
-				const sizeBytes = stream.sizeBytes ?? 0;
-				const metadataStr =
-					Object.keys(stream.metadata).length > 0 ? JSON.stringify(stream.metadata) : '-';
-				return {
-					Namespace: stream.namespace,
-					ID: stream.id,
-					Size: tui.formatBytes(sizeBytes),
-					Metadata:
-						metadataStr.length > 40 ? metadataStr.substring(0, 37) + '...' : metadataStr,
-					URL: tui.link(stream.url),
-				};
+		} catch (ex) {
+			if (ex instanceof StreamListError) {
+				throw ex;
+			}
+			throw new StreamListError({
+				message: `Failed to list streams: ${ex}`,
+				namespace: opts.namespace,
+				projectId,
+				orgId: opts.orgId,
 			});
-
-			tui.table(tableData, [
-				{ name: 'Namespace', alignment: 'left' },
-				{ name: 'ID', alignment: 'left' },
-				{ name: 'Size', alignment: 'right' },
-				{ name: 'Metadata', alignment: 'left' },
-				{ name: 'URL', alignment: 'left' },
-			]);
-
-			tui.info(`Total: ${result.total} ${tui.plural(result.total, 'stream', 'streams')}`);
 		}
-
-		return {
-			streams: result.streams,
-			total: result.total,
-		};
 	},
 });
 

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

@@ -4,6 +4,16 @@ import { loadProjectSDKKey } from '../../../config';
 import type { AuthData, Config, GlobalOptions, ProjectConfig } from '../../../types';
 import * as tui from '../../../tui';
 
+/**
+ * Create a storage adapter for stream operations that create new streams.
+ * This is used by the `stream create` command.
+ *
+ * For listing and deleting streams, use the CLI API endpoints (streamList, streamGet)
+ * which handle org resolution automatically based on user's org membership.
+ *
+ * @param ctx - Command context including auth, region, and optional project context
+ * @returns A StreamStorageService instance configured for the org
+ */
 export async function createStorageAdapter(ctx: {
 	logger: Logger;
 	projectDir: string;
@@ -26,8 +36,7 @@ export async function createStorageAdapter(ctx: {
 	} else {
 		// Use CLI key auth with orgId query param
 		// Pulse server expects orgId as query param for CLI tokens (ck_*)
-		// IMPORTANT: For CLI key auth, prefer user's org ID over project's org ID
-		// because the CLI key is validated against the user's orgs, not the project's org
+		// For create operations, we need to know which org to create the stream in
 		const orgId =
 			ctx.options.orgId ??
 			process.env.AGENTUITY_CLOUD_ORG_ID ??
@@ -36,7 +45,7 @@ export async function createStorageAdapter(ctx: {
 
 		if (!orgId) {
 			tui.fatal(
-				'Organization ID is required. Either run from a project directory, use --org-id flag, or set AGENTUITY_CLOUD_ORG_ID environment variable.'
+				'Organization ID is required for creating streams. Either run from a project directory, use --org-id flag, or set AGENTUITY_CLOUD_ORG_ID environment variable.'
 			);
 		}
 
@@ -61,3 +70,30 @@ export async function createStorageAdapter(ctx: {
 
 	return new StreamStorageService(baseUrl, adapter);
 }
+
+/**
+ * Create a storage adapter for a specific org ID.
+ * Used when listing streams across multiple orgs.
+ */
+export function createStorageAdapterForOrg(ctx: {
+	logger: Logger;
+	auth: AuthData;
+	region: string;
+	orgId: string;
+}) {
+	const baseUrl = getServiceUrls(ctx.region).stream;
+
+	const adapter = createServerFetchAdapter(
+		{
+			headers: {
+				Authorization: `Bearer ${ctx.auth.apiKey}`,
+			},
+			queryParams: { orgId: ctx.orgId },
+		},
+		ctx.logger
+	);
+
+	ctx.logger.trace('using stream url: %s for org: %s', baseUrl, ctx.orgId);
+
+	return new StreamStorageService(baseUrl, adapter);
+}

package/src/cmd/cloud/vector/util.ts

@@ -1,6 +1,7 @@
 import { type Logger, VectorStorageService } from '@agentuity/core';
-import { createServerFetchAdapter, getServiceUrls } from '@agentuity/server';
+import { createServerFetchAdapter } from '@agentuity/server';
 import type { AuthData, Config, GlobalOptions, ProjectConfig } from '../../../types';
+import { getCatalystUrl } from '../../../catalyst';
 import * as tui from '../../../tui';
 
 export function createStorageAdapter(ctx: {
@@ -31,7 +32,6 @@ export function createStorageAdapter(ctx: {
 		ctx.logger
 	);
 
-	const urls = getServiceUrls(ctx.region);
-	const baseUrl = urls.catalyst;
+	const baseUrl = getCatalystUrl(ctx.region);
 	return new VectorStorageService(baseUrl, adapter);
 }

package/src/cmd/dev/index.ts

@@ -1177,10 +1177,10 @@ export const command = createCommand({
 										const text = new TextDecoder().decode(chunk);
 										const trimmed = text.trim();
 
-								// Check for heartbeat port announcement
-								const match = trimmed.match(/^HEARTBEAT_PORT=(\d+)$/m);
-								if (match?.[1]) {
-									const heartbeatPort = parseInt(match[1], 10);
+										// Check for heartbeat port announcement
+										const match = trimmed.match(/^HEARTBEAT_PORT=(\d+)$/m);
+										if (match?.[1]) {
+											const heartbeatPort = parseInt(match[1], 10);
 											logger.debug('Gravity heartbeat port detected: %d', heartbeatPort);
 
 											// Start sending heartbeats every 5 seconds

package/src/cmd/git/account/add.ts

@@ -252,11 +252,11 @@ export const addSubcommand = createSubcommand({
 
 				const sortedOrgs = [...orgStatuses].sort((a, b) => a.name.localeCompare(b.name));
 
-			const firstOrg = orgs[0];
-			if (orgs.length === 1 && firstOrg) {
-				orgId = firstOrg.id;
-				selectedOrg = firstOrg;
-			} else {
+				const firstOrg = orgs[0];
+				if (orgs.length === 1 && firstOrg) {
+					orgId = firstOrg.id;
+					selectedOrg = firstOrg;
+				} else {
 					const choices = sortedOrgs.map((org) => {
 						const count = org.integrations.length;
 						const suffix =

package/src/cmd/git/list.ts

@@ -53,13 +53,13 @@ export const listSubcommand = createSubcommand({
 				return [];
 			}
 
-		// Select org
-		let orgId = opts.org;
-		if (!orgId) {
-			const firstOrg = orgs[0];
-			if (orgs.length === 1 && firstOrg) {
-				orgId = firstOrg.id;
-			} else {
+			// Select org
+			let orgId = opts.org;
+			if (!orgId) {
+				const firstOrg = orgs[0];
+				if (orgs.length === 1 && firstOrg) {
+					orgId = firstOrg.id;
+				} else {
 					tui.newline();
 					const orgChoices = orgs.map((o) => ({
 						name: o.id,

package/src/cmd/project/add/database.ts

@@ -0,0 +1,145 @@
+import { z } from 'zod';
+import { listResources } from '@agentuity/server';
+import { createSubcommand } from '../../../types';
+import * as tui from '../../../tui';
+import { createPrompt } from '../../../tui';
+import { getCatalystAPIClient } from '../../../config';
+import { getCommand } from '../../../command-prefix';
+import { isDryRunMode, outputDryRun } from '../../../explain';
+import { ErrorCode } from '../../../errors';
+import { addResourceEnvVars } from '../../../env-util';
+
+export const databaseSubcommand = createSubcommand({
+	name: 'database',
+	aliases: ['db'],
+	description: 'Link an existing database to the current project',
+	tags: ['mutating', 'fast', 'requires-auth', 'requires-project'],
+	idempotent: true,
+	requires: { auth: true, org: true, region: true, project: true },
+	examples: [
+		{
+			command: getCommand('project add database'),
+			description: 'Select a database interactively',
+		},
+		{
+			command: getCommand('project add db my-db'),
+			description: 'Link a specific database by name',
+		},
+		{
+			command: getCommand('--dry-run project add database my-db'),
+			description: 'Preview linking without making changes',
+		},
+	],
+	schema: {
+		args: z.object({
+			name: z.string().optional().describe('Database name to link'),
+		}),
+		options: z.object({}),
+		response: z.object({
+			success: z.boolean().describe('Whether linking succeeded'),
+			name: z.string().describe('Linked database name'),
+		}),
+	},
+
+	async handler(ctx) {
+		const { logger, args, orgId, region, auth, options, projectDir } = ctx;
+
+		if (isDryRunMode(options)) {
+			const message = args.name
+				? `Would link database "${args.name}" to project in ${projectDir}`
+				: `Would prompt to select a database to link to project in ${projectDir}`;
+			outputDryRun(message, options);
+			if (!options.json) {
+				tui.newline();
+				tui.info('[DRY RUN] Database linking skipped');
+			}
+			return {
+				success: false,
+				name: args.name || 'dry-run-db',
+			};
+		}
+
+		const catalystClient = getCatalystAPIClient(logger, auth, region);
+
+		const resources = await tui.spinner({
+			message: 'Fetching databases',
+			clearOnSuccess: true,
+			callback: async () => {
+				return listResources(catalystClient, orgId, region);
+			},
+		});
+
+		const availableDatabases = resources.db.filter((db) => !db.internal);
+
+		if (availableDatabases.length === 0) {
+			tui.fatal(
+				'No databases available. Create one first with: ' +
+					tui.bold(getCommand('cloud db create')),
+				ErrorCode.RESOURCE_NOT_FOUND
+			);
+		}
+
+		let selectedDatabase: (typeof availableDatabases)[0] | undefined;
+
+		if (args.name) {
+			selectedDatabase = availableDatabases.find((db) => db.name === args.name);
+			if (!selectedDatabase) {
+				const availableNames = availableDatabases.map((db) => db.name).join(', ');
+				tui.fatal(
+					`Database "${args.name}" not found. Available databases: ${availableNames}`,
+					ErrorCode.RESOURCE_NOT_FOUND
+				);
+			}
+		} else {
+			const isHeadless = !process.stdin.isTTY || !process.stdout.isTTY;
+			if (isHeadless) {
+				tui.fatal(
+					'Database name is required in non-interactive mode. Usage: ' +
+						tui.bold(getCommand('project add database <name>')),
+					ErrorCode.MISSING_ARGUMENT
+				);
+			}
+
+			const prompt = createPrompt();
+			const selected = await prompt.select<string>({
+				message: 'Select a database to link',
+				options: availableDatabases.map((db) => ({
+					value: db.name,
+					label: `${tui.tuiColors.primary(db.name)}`,
+				})),
+			});
+
+			// Ensure stdin is paused so process can exit
+			if (process.stdin.isTTY) {
+				process.stdin.pause();
+			}
+
+			if (!selected) {
+				tui.fatal('Operation cancelled', ErrorCode.USER_CANCELLED);
+			}
+
+			selectedDatabase = availableDatabases.find((db) => db.name === selected);
+		}
+
+		if (!selectedDatabase) {
+			tui.fatal('Failed to select database', ErrorCode.INTERNAL_ERROR);
+		}
+
+		if (selectedDatabase.env && Object.keys(selectedDatabase.env).length > 0) {
+			await addResourceEnvVars(projectDir, selectedDatabase.env);
+			if (!options.json) {
+				tui.success(`Linked database: ${tui.bold(selectedDatabase.name)}`);
+				tui.info('Environment variables written to .env');
+			}
+		} else {
+			if (!options.json) {
+				tui.warning(`Database "${selectedDatabase.name}" has no environment variables to add`);
+			}
+		}
+
+		return {
+			success: true,
+			name: selectedDatabase.name,
+		};
+	},
+});

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

@@ -0,0 +1,181 @@
+import { z } from 'zod';
+import { createSubcommand } from '../../../types';
+import * as tui from '../../../tui';
+import { createPrompt } from '../../../tui';
+import { getCommand } from '../../../command-prefix';
+import { isDryRunMode, outputDryRun } from '../../../explain';
+import { ErrorCode } from '../../../errors';
+import { loadProjectConfig, updateProjectConfig } from '../../../config';
+import { checkCustomDomainForDNS, isSuccess, isMisconfigured, isError } from '../../../domain';
+
+export const domainSubcommand = createSubcommand({
+	name: 'domain',
+	aliases: ['dns'],
+	description: 'Add a custom domain to the current project',
+	tags: ['mutating', 'slow', 'requires-auth', 'requires-project'],
+	idempotent: true,
+	requires: { auth: true, org: true, region: true, project: true },
+	examples: [
+		{
+			command: getCommand('project add domain example.com'),
+			description: 'Add a custom domain',
+		},
+		{
+			command: getCommand('project add domain example.com --skip-validation'),
+			description: 'Add a domain without DNS validation',
+		},
+		{
+			command: getCommand('--dry-run project add domain example.com'),
+			description: 'Preview adding a domain without making changes',
+		},
+	],
+	schema: {
+		args: z.object({
+			domain: z.string().describe('Domain name to add'),
+		}),
+		options: z.object({
+			skipValidation: z
+				.boolean()
+				.optional()
+				.describe('Skip DNS validation (domain will be validated on deploy)'),
+		}),
+		response: z.object({
+			success: z.boolean().describe('Whether adding the domain succeeded'),
+			domain: z.string().describe('Added domain name'),
+			domains: z.array(z.string()).describe('All configured domains'),
+			dryRun: z.boolean().optional().describe('True if this was a dry-run preview'),
+		}),
+	},
+
+	async handler(ctx) {
+		const { args, opts, options, projectDir, config, logger } = ctx;
+
+		if (isDryRunMode(options)) {
+			const message = `Would add domain "${args.domain}" to project in ${projectDir}`;
+			outputDryRun(message, options);
+			if (!options.json) {
+				tui.newline();
+				tui.info('[DRY RUN] Domain addition skipped');
+			}
+			return {
+				success: true,
+				dryRun: true,
+				domain: args.domain,
+				domains: [],
+			};
+		}
+
+		const project = await loadProjectConfig(projectDir, config);
+		const existingDomains = project.deployment?.domains ?? [];
+
+		const domain = args.domain.toLowerCase().trim();
+
+		// Validate domain format
+		const domainRegex =
+			/^[a-zA-Z0-9]([a-zA-Z0-9-]*[a-zA-Z0-9])?(\.[a-zA-Z0-9]([a-zA-Z0-9-]*[a-zA-Z0-9])?)+$/;
+		if (!domainRegex.test(domain)) {
+			logger.fatal('Please enter a valid domain name', ErrorCode.VALIDATION_FAILED);
+		}
+
+		// Check if domain already exists
+		if (existingDomains.includes(domain)) {
+			if (!options.json) {
+				tui.warning(`Domain "${domain}" is already configured for this project`);
+			}
+			return {
+				success: false,
+				domain,
+				domains: existingDomains,
+			};
+		}
+
+		// Validate DNS unless skipped
+		if (!opts?.skipValidation) {
+			const results = await tui.spinner({
+				message: `Checking DNS for ${domain}`,
+				clearOnSuccess: true,
+				callback: async () => {
+					return checkCustomDomainForDNS(project.projectId, [domain], config);
+				},
+			});
+
+			// Handle empty results - DNS validation service returned no data
+			if (results.length === 0) {
+				logger.fatal(
+					`DNS validation failed: no response from DNS validation service for domain "${domain}". ` +
+						'Use --skip-validation to add the domain without DNS verification.',
+					ErrorCode.VALIDATION_FAILED
+				);
+			}
+
+			// Safe to assert non-null since we've checked results.length above
+			// (logger.fatal never returns - it exits the process)
+			const result = results[0]!;
+			if (!isSuccess(result)) {
+				if (isError(result)) {
+					logger.fatal(`DNS validation failed: ${result.error}`, ErrorCode.VALIDATION_FAILED);
+				}
+
+				tui.newline();
+				tui.warning('DNS record not yet configured. Please add the following CNAME record:');
+				tui.newline();
+				tui.output(`  ${tui.colorInfo('Domain:')}  ${tui.colorPrimary(result.domain)}`);
+				tui.output(`  ${tui.colorInfo('Type:')}    ${tui.colorPrimary(result.recordType)}`);
+				tui.output(`  ${tui.colorInfo('Target:')}  ${tui.colorPrimary(result.target)}`);
+				tui.newline();
+
+				if (isMisconfigured(result)) {
+					tui.error(`Current configuration: ${result.misconfigured}`);
+					tui.newline();
+				}
+
+				// In non-interactive mode, fail with guidance
+				const isHeadless = !process.stdin.isTTY || !process.stdout.isTTY;
+				if (isHeadless) {
+					logger.fatal(
+						'DNS is not configured. Add the DNS record above and try again, or use --skip-validation',
+						ErrorCode.VALIDATION_FAILED
+					);
+				}
+
+				const prompt = createPrompt();
+				const proceed = await prompt.confirm({
+					message: 'Add domain anyway? (DNS will be validated on deploy)',
+					initial: true,
+				});
+
+				if (process.stdin.isTTY) {
+					process.stdin.pause();
+				}
+
+				if (!proceed) {
+					logger.fatal('Operation cancelled', ErrorCode.USER_CANCELLED);
+				}
+			}
+		}
+
+		// Update the project config
+		const updatedDomains = [...existingDomains, domain];
+		await updateProjectConfig(
+			projectDir,
+			{
+				deployment: {
+					...project.deployment,
+					domains: updatedDomains,
+				},
+			},
+			config
+		);
+
+		if (!options.json) {
+			tui.success(`Added domain: ${tui.bold(domain)}`);
+			tui.info('Domain will be active after next deployment');
+		}
+
+		return {
+			success: true,
+			domain,
+			domains: updatedDomains,
+		};
+	},
+});

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

@@ -0,0 +1,35 @@
+import { createCommand } from '../../../types';
+import { databaseSubcommand } from './database';
+import { domainSubcommand } from './domain';
+import { storageSubcommand } from './storage';
+import { getCommand } from '../../../command-prefix';
+
+export const addCommand = createCommand({
+	name: 'add',
+	aliases: ['link'],
+	description: 'Link existing cloud resources to the current project',
+	tags: ['fast', 'requires-auth', 'requires-project'],
+	examples: [
+		{
+			command: getCommand('project add database'),
+			description: 'Link an existing database to the project',
+		},
+		{
+			command: getCommand('project add storage'),
+			description: 'Link an existing storage bucket to the project',
+		},
+		{
+			command: getCommand('project add domain example.com'),
+			description: 'Add a custom domain to the project',
+		},
+		{
+			command: getCommand('project add database my-db'),
+			description: 'Link a specific database by name',
+		},
+		{
+			command: getCommand('project add storage my-bucket'),
+			description: 'Link a specific storage bucket by name',
+		},
+	],
+	subcommands: [databaseSubcommand, domainSubcommand, storageSubcommand],
+});