@agentuity/cli 1.0.1 → 1.0.3

package/src/cmd/build/vite/vite-builder.ts

@@ -63,6 +63,8 @@ export interface ViteBuildOptions {
 	deploymentOptions?: DeployOptions;
 	/** Optional collector for structured error reporting */
 	collector?: BuildReportCollector;
+	/** Optional config profile name (e.g., 'staging', 'test') for .env.{profile} files */
+	profile?: string;
 }
 
 /**
@@ -70,7 +72,15 @@ export interface ViteBuildOptions {
  * Uses inline Vite config (customizable via agentuity.config.ts)
  */
 export async function runViteBuild(options: ViteBuildOptions): Promise<void> {
-	const { rootDir, mode, dev = false, projectId = '', deploymentId = '', logger } = options;
+	const {
+		rootDir,
+		mode,
+		dev = false,
+		projectId = '',
+		deploymentId = '',
+		logger,
+		profile,
+	} = options;
 
 	logger.debug(`Running Vite build for mode: ${mode}`);
 
@@ -93,6 +103,16 @@ export async function runViteBuild(options: ViteBuildOptions): Promise<void> {
 		const { generateLifecycleTypes } = await import('./lifecycle-generator');
 		await generateLifecycleTypes(rootDir, srcDir, logger);
 
+		// Generate environment types from local .env files
+		const { generateEnvTypes } = await import('./env-types-generator');
+		await generateEnvTypes({
+			rootDir,
+			srcDir,
+			logger,
+			isProduction: !dev,
+			profile,
+		});
+
 		// Load workbench config for entry file generation
 		const { loadAgentuityConfig, getWorkbenchConfig } = await import('./config-loader');
 		const config = await loadAgentuityConfig(rootDir, logger);
@@ -203,17 +223,17 @@ export async function runViteBuild(options: ViteBuildOptions): Promise<void> {
 					? JSON.stringify(workbenchRoute)
 					: 'undefined',
 			},
-		build: {
-			outDir: clientOutDir,
-			rollupOptions: {
-				input: htmlPath,
+			build: {
+				outDir: clientOutDir,
+				rollupOptions: {
+					input: htmlPath,
+				},
+				manifest: true,
+				emptyOutDir: true,
+				// Copy public files to output for CDN upload (production builds only)
+				// In dev mode, Vite serves them directly from src/web/public/
+				copyPublicDir: !dev,
 			},
-			manifest: true,
-			emptyOutDir: true,
-			// Copy public files to output for CDN upload (production builds only)
-			// In dev mode, Vite serves them directly from src/web/public/
-			copyPublicDir: !dev,
-		},
 			logLevel: 'warn',
 		};
 	} else if (mode === 'workbench') {

package/src/cmd/cloud/db/create.ts

@@ -74,24 +74,24 @@ export const createSubcommand = defineSubcommand({
 					]);
 				},
 			});
-		const resource = created[0];
-		if (resource) {
-			// Write environment variables to .env if running inside a project
-			if (ctx.projectDir && resource.env && Object.keys(resource.env).length > 0) {
-				await addResourceEnvVars(ctx.projectDir, resource.env);
-				if (!options.json) {
-					tui.info('Environment variables written to .env');
+			const resource = created[0];
+			if (resource) {
+				// Write environment variables to .env if running inside a project
+				if (ctx.projectDir && resource.env && Object.keys(resource.env).length > 0) {
+					await addResourceEnvVars(ctx.projectDir, resource.env);
+					if (!options.json) {
+						tui.info('Environment variables written to .env');
+					}
 				}
-			}
 
-			if (!options.json) {
-				tui.success(`Created database: ${tui.bold(resource.name)}`);
-			}
-			return {
-				success: true,
-				name: resource.name,
-			};
-		} else {
+				if (!options.json) {
+					tui.success(`Created database: ${tui.bold(resource.name)}`);
+				}
+				return {
+					success: true,
+					name: resource.name,
+				};
+			} else {
 				tui.fatal('Failed to create database');
 			}
 		} catch (ex) {

package/src/cmd/cloud/db/delete.ts

@@ -178,27 +178,27 @@ export const deleteSubcommand = createSubcommand({
 				},
 			});
 
-		const resource = deleted[0];
-		if (resource) {
-			// Clear cache entry for deleted database
-			await deleteResourceRegion('db', profileName, resource.name);
-
-			// Remove env vars from .env if running inside a project
-			if (ctx.projectDir && resource.env_keys.length > 0) {
-				await removeResourceEnvVars(ctx.projectDir, resource.env_keys);
-				if (!options.json) {
-					tui.info(`Removed ${resource.env_keys.join(', ')} from .env`);
+			const resource = deleted[0];
+			if (resource) {
+				// Clear cache entry for deleted database
+				await deleteResourceRegion('db', profileName, resource.name);
+
+				// Remove env vars from .env if running inside a project
+				if (ctx.projectDir && resource.env_keys.length > 0) {
+					await removeResourceEnvVars(ctx.projectDir, resource.env_keys);
+					if (!options.json) {
+						tui.info(`Removed ${resource.env_keys.join(', ')} from .env`);
+					}
 				}
-			}
 
-			if (!options.json) {
-				tui.success(`Deleted database: ${tui.bold(resource.name)}`);
-			}
-			return {
-				success: true,
-				name: resource.name,
-			};
-		} else {
+				if (!options.json) {
+					tui.success(`Deleted database: ${tui.bold(resource.name)}`);
+				}
+				return {
+					success: true,
+					name: resource.name,
+				};
+			} else {
 				tui.error('Failed to delete database');
 				return { success: false, name: dbName };
 			}

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

@@ -5,7 +5,7 @@ import * as tui from '../../../tui';
 import { getGlobalCatalystAPIClient, getCatalystAPIClient } from '../../../config';
 import { getCommand } from '../../../command-prefix';
 import { ErrorCode } from '../../../errors';
-import { getResourceInfo, setResourceInfo } from '../../../cache';
+import { setResourceInfo } from '../../../cache';
 
 const DBGetResponseSchema = z
 	.object({
@@ -27,7 +27,6 @@ export const getSubcommand = createSubcommand({
 	description: 'Show details about a specific database',
 	tags: ['read-only', 'fast', 'requires-auth'],
 	requires: { auth: true },
-	optional: { org: true },
 	idempotent: true,
 	examples: [
 		{ command: `${getCommand('cloud db get')} my-database`, description: 'Get database details' },
@@ -52,6 +51,22 @@ export const getSubcommand = createSubcommand({
 			description: 'Get table schemas as JSON',
 		},
 	],
+	resourceRules: [
+		{
+			resource: 'org',
+			required: false,
+			flag: 'org-id',
+			envVar: 'AGENTUITY_CLOUD_ORG_ID',
+			canUseCache: true,
+		},
+		{
+			resource: 'region',
+			required: false,
+			flag: 'region',
+			envVar: 'AGENTUITY_REGION',
+			operationType: 'read',
+		},
+	],
 	schema: {
 		args: z.object({
 			name: z.string().describe('Database name'),
@@ -76,30 +91,20 @@ export const getSubcommand = createSubcommand({
 		const profileName = config?.name ?? 'production';
 		const globalClient = await getGlobalCatalystAPIClient(logger, auth, profileName);
 
-		// Check cache first for orgId
-		const cachedInfo = await getResourceInfo('db', profileName, args.name);
-		const orgId = ctx.orgId ?? cachedInfo?.orgId;
-
-		if (!orgId) {
-			tui.fatal(
-				`Organization not found for database '${args.name}'. Run 'agentuity cloud db list' first or specify --org-id.`,
-				ErrorCode.INVALID_ARGUMENT
-			);
-		}
-
+		// Search across all orgs the user has access to
 		const resources = await tui.spinner({
 			message: `Fetching database ${args.name}`,
 			clearOnSuccess: true,
 			callback: async () => {
-				return listOrgResources(globalClient, { type: 'db', orgId });
+				return listOrgResources(globalClient, { type: 'db' });
 			},
 		});
 
 		const db = resources.db.find((d) => d.name === args.name);
 
 		// Cache the database info for future lookups
-		if (db?.cloud_region) {
-			await setResourceInfo('db', profileName, db.name, db.cloud_region, orgId);
+		if (db?.cloud_region && db.org_id) {
+			await setResourceInfo('db', profileName, db.name, db.cloud_region, db.org_id);
 		}
 
 		if (!db) {
@@ -111,13 +116,23 @@ export const getSubcommand = createSubcommand({
 		if (opts.showTables) {
 			const region = db.cloud_region;
 			const regionalClient = getCatalystAPIClient(logger, auth, region);
+
+			// Validate org_id is present - dbTables requires orgId for authorization
+			// Some internal databases may not have org_id set, which would fail the API call
+			if (!db.org_id) {
+				tui.fatal(
+					`Database '${args.name}' is missing organization information and cannot be queried for tables`,
+					ErrorCode.RESOURCE_NOT_FOUND
+				);
+			}
+
 			const tables = await tui.spinner({
 				message: `Fetching table schemas for ${args.name}`,
 				clearOnSuccess: true,
 				callback: async () => {
 					return dbTables(regionalClient, {
 						database: args.name,
-						orgId,
+						orgId: db.org_id,
 						region,
 					});
 				},

package/src/cmd/cloud/deploy-fork.ts

@@ -17,6 +17,7 @@ import { existsSync, readFileSync, unlinkSync } from 'node:fs';
 import type { APIClient } from '../../api';
 import { getUserAgent } from '../../api';
 import { isUnicode } from '../../tui/symbols';
+import { getAgentEnv } from '../../agent-detection';
 import { projectDeploymentFail, type ClientDiagnostics, type Deployment } from '@agentuity/server';
 import type { Logger } from '@agentuity/core';
 
@@ -174,6 +175,7 @@ export async function runForkedDeploy(options: ForkDeployOptions): Promise<ForkD
 			cwd: projectDir,
 			env: {
 				...process.env,
+				...getAgentEnv(),
 				AGENTUITY_FORK_PARENT: '1',
 				AGENTUITY_DEPLOYMENT: deploymentEnvValue,
 				// Force color and unicode output since child stdout/stderr are piped (not TTY)

package/src/cmd/cloud/deploy.ts

@@ -106,6 +106,23 @@ export const deploySubcommand = createSubcommand({
 	idempotent: false,
 	requires: { auth: true, project: true, apiClient: true },
 	prerequisites: ['auth login'],
+	resourceRules: [
+		{
+			resource: 'project',
+			required: true,
+			flag: 'project-id',
+			envVar: 'AGENTUITY_CLOUD_PROJECT_ID',
+			impliedFrom: 'agentuity.json',
+		},
+		{
+			resource: 'region',
+			required: true,
+			flag: 'region',
+			envVar: 'AGENTUITY_REGION',
+			configPref: 'region',
+			operationType: 'mutate',
+		},
+	],
 	schema: {
 		options: z.intersection(
 			DeployOptionsSchema,

package/src/cmd/cloud/env/import.ts

@@ -113,14 +113,14 @@ export const importSubcommand = createSubcommand({
 			tui.warning(
 				`Moving public variables to env: ${publicSecretKeys.join(', ')} (these are exposed to the frontend)`
 			);
-		for (const key of publicSecretKeys) {
-			delete secrets[key];
-			const value = filteredVars[key];
-			if (value !== undefined) {
-				env[key] = value;
+			for (const key of publicSecretKeys) {
+				delete secrets[key];
+				const value = filteredVars[key];
+				if (value !== undefined) {
+					env[key] = value;
+				}
 			}
 		}
-		}
 
 		const envCount = Object.keys(env).length;
 		const secretCount = Object.keys(secrets).length;

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

@@ -168,17 +168,17 @@ export const listSubcommand = createSubcommand({
 				const sortedKeys = Object.keys(result).sort();
 				const shouldMask = opts?.mask !== false;
 
-			for (const key of sortedKeys) {
-				const entry = result[key];
-				if (!entry) continue;
-				const { value, secret, scope } = entry;
-				const displayValue = shouldMask && secret ? tui.maskSecret(value) : value;
-				const typeIndicator = secret ? ' [secret]' : '';
-				const scopeIndicator = !useOrgScope ? ` [${scope}]` : '';
-				console.log(
-					`${tui.bold(key)}=${displayValue}${tui.muted(typeIndicator + scopeIndicator)}`
-				);
-			}
+				for (const key of sortedKeys) {
+					const entry = result[key];
+					if (!entry) continue;
+					const { value, secret, scope } = entry;
+					const displayValue = shouldMask && secret ? tui.maskSecret(value) : value;
+					const typeIndicator = secret ? ' [secret]' : '';
+					const scopeIndicator = !useOrgScope ? ` [${scope}]` : '';
+					console.log(
+						`${tui.bold(key)}=${displayValue}${tui.muted(typeIndicator + scopeIndicator)}`
+					);
+				}
 			}
 		}
 

package/src/cmd/cloud/env/push.ts

@@ -80,14 +80,14 @@ export const pushSubcommand = createSubcommand({
 			tui.warning(
 				`Moving public variables to env: ${publicSecretKeys.join(', ')} (these are exposed to the frontend)`
 			);
-		for (const key of publicSecretKeys) {
-			delete secrets[key];
-			const value = filteredEnv[key];
-			if (value !== undefined) {
-				env[key] = value;
+			for (const key of publicSecretKeys) {
+				delete secrets[key];
+				const value = filteredEnv[key];
+				if (value !== undefined) {
+					env[key] = value;
+				}
 			}
 		}
-		}
 
 		if (useOrgScope) {
 			// Organization scope

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

@@ -1,6 +1,7 @@
 import { KeyValueStorageService, type Logger } 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 KeyValueStorageService(baseUrl, adapter);
 }

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

@@ -32,15 +32,15 @@ export const listSubcommand = createSubcommand({
 		},
 	],
 	aliases: ['ls'],
-	requires: { auth: true, org: true },
+	requires: { auth: true },
 	idempotent: true,
 	schema: {
 		response: MachineListResponseSchema,
 	},
 	async handler(ctx) {
-		const { options, logger, auth, config, orgId } = ctx;
+		const { options, logger, auth, config } = ctx;
 
-		const catalystClient = await getGlobalCatalystAPIClient(logger, auth, config?.name, orgId);
+		const catalystClient = await getGlobalCatalystAPIClient(logger, auth, config?.name);
 
 		try {
 			const machines = await machineList(catalystClient);

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

@@ -45,9 +45,9 @@ const selectCommand = createSubcommand({
 				);
 			}
 
-		if (regions.length === 1 && regions[0]) {
-			selectedRegion = regions[0].region;
-		} else {
+			if (regions.length === 1 && regions[0]) {
+				selectedRegion = regions[0].region;
+			} else {
 				const response = await tui.createPrompt().select<string>({
 					message: 'Select a default region',
 					options: regions.map((r) => ({

package/src/cmd/cloud/region-lookup.ts

@@ -1,12 +1,19 @@
-import type { Logger } from '@agentuity/core';
-import { projectGet, sandboxGet, deploymentGet, type APIClient } from '@agentuity/server';
-import { getResourceRegion, setResourceRegion } from '../../cache';
-import { getGlobalCatalystAPIClient } from '../../config';
+import { StreamStorageService, type Logger } from '@agentuity/core';
+import {
+	projectGet,
+	sandboxResolve,
+	deploymentGet,
+	type APIClient,
+	createServerFetchAdapter,
+	getServiceUrls,
+} from '@agentuity/server';
+import { getResourceInfo, setResourceInfo } from '../../cache';
+import { getDefaultRegion } from '../../config';
 import type { AuthData, Config } from '../../types';
 import * as tui from '../../tui';
 import { ErrorCode } from '../../errors';
 
-export type IdentifierType = 'project' | 'deployment' | 'sandbox';
+export type IdentifierType = 'project' | 'deployment' | 'sandbox' | 'stream';
 
 /**
  * Determine the type of identifier based on its prefix
@@ -21,18 +28,24 @@ export function getIdentifierType(identifier: string): IdentifierType {
 	if (identifier.startsWith('sbx_')) {
 		return 'sandbox';
 	}
+	if (identifier.startsWith('stream_')) {
+		return 'stream';
+	}
 	// Default to project for unknown prefixes
 	return 'project';
 }
 
 /**
- * Look up the region for a project, deployment, or sandbox identifier.
+ * Look up the region for a project, deployment, sandbox, or stream identifier.
  * Uses cache-first strategy with API fallback.
+ *
+ * @param apiClient - Required for project/deployment lookups, optional for sandbox/stream
+ *                    (they create their own clients internally)
  */
 export async function getIdentifierRegion(
 	logger: Logger,
 	auth: AuthData,
-	apiClient: APIClient,
+	apiClient: APIClient | undefined,
 	profileName = 'production',
 	identifier: string,
 	orgId?: string,
@@ -41,10 +54,10 @@ export async function getIdentifierRegion(
 	const identifierType = getIdentifierType(identifier);
 
 	// For project, deployment, and sandbox, check cache first
-	const cachedRegion = await getResourceRegion(identifierType, profileName, identifier);
-	if (cachedRegion) {
-		logger.trace(`[region-lookup] Found cached region for ${identifier}: ${cachedRegion}`);
-		return cachedRegion;
+	const cachedInfo = await getResourceInfo(identifierType, profileName, identifier);
+	if (cachedInfo?.region) {
+		logger.trace(`[region-lookup] Found cached region for ${identifier}: ${cachedInfo.region}`);
+		return cachedInfo.region;
 	}
 
 	logger.trace(`[region-lookup] Cache miss for ${identifier}, fetching from API`);
@@ -52,22 +65,69 @@ export async function getIdentifierRegion(
 	let region: string | null = null;
 
 	if (identifierType === 'project') {
+		if (!apiClient) {
+			tui.fatal(
+				`API client required for project region lookup. This is an internal error.`,
+				ErrorCode.INVALID_ARGUMENT
+			);
+		}
 		const project = await projectGet(apiClient, { id: identifier, mask: true, keys: false });
 		region = project.cloudRegion ?? null;
 	} else if (identifierType === 'deployment') {
+		if (!apiClient) {
+			tui.fatal(
+				`API client required for deployment region lookup. This is an internal error.`,
+				ErrorCode.INVALID_ARGUMENT
+			);
+		}
 		const deployment = await deploymentGet(apiClient, identifier);
 		region = deployment.cloudRegion ?? null;
+	} else if (identifierType === 'sandbox') {
+		// sandbox - use CLI API to resolve across all orgs the user has access to
+		if (!apiClient) {
+			tui.fatal(
+				`API client required for sandbox region lookup. This is an internal error.`,
+				ErrorCode.INVALID_ARGUMENT
+			);
+		}
+		const sandbox = await sandboxResolve(apiClient, identifier);
+		region = sandbox.region ?? null;
+		// Cache the orgId along with the region for future lookups
+		if (sandbox.orgId) {
+			orgId = sandbox.orgId;
+		}
 	} else {
-		// sandbox - pass config to getGlobalCatalystAPIClient for proper region resolution
-		const globalClient = await getGlobalCatalystAPIClient(
-			logger,
-			auth,
-			profileName,
-			orgId,
-			config
+		// stream - use the streams service to look up stream info
+		// Any regional streams service can look up any stream and return its info
+		// The service authenticates based on user's org membership, no explicit orgId needed
+		const defaultRegion = await getDefaultRegion(profileName, config);
+		const baseUrl = getServiceUrls(defaultRegion).stream;
+
+		// Include orgId if available, but don't require it
+		const resolvedOrgId =
+			orgId ?? process.env.AGENTUITY_CLOUD_ORG_ID ?? config?.preferences?.orgId;
+
+		const adapter = createServerFetchAdapter(
+			{
+				headers: {
+					Authorization: `Bearer ${auth.apiKey}`,
+				},
+				queryParams: resolvedOrgId ? { orgId: resolvedOrgId } : undefined,
+			},
+			logger
 		);
-		const sandbox = await sandboxGet(globalClient, { sandboxId: identifier, orgId });
-		region = sandbox.region ?? null;
+
+		const streamService = new StreamStorageService(baseUrl, adapter);
+		const streamInfo = await streamService.get(identifier);
+
+		// Extract region from the stream URL (e.g., https://streams-use.agentuity.cloud/...)
+		const urlMatch = streamInfo.url.match(/https:\/\/streams-([^.]+)\.agentuity\.cloud/);
+		if (urlMatch?.[1]) {
+			region = urlMatch[1];
+		} else if (streamInfo.url.includes('streams.agentuity.io')) {
+			// Local environment
+			region = 'local';
+		}
 	}
 
 	if (!region) {
@@ -86,7 +146,7 @@ export async function getIdentifierRegion(
 	}
 
 	// Cache the result
-	await setResourceRegion(identifierType, profileName, identifier, region);
+	await setResourceInfo(identifierType, profileName, identifier, region, orgId);
 	logger.trace(`[region-lookup] Cached region for ${identifier}: ${region}`);
 
 	return region;
@@ -100,5 +160,5 @@ export async function cacheProjectRegion(
 	projectId: string,
 	region: string
 ): Promise<void> {
-	await setResourceRegion('project', profileName, projectId, region);
+	await setResourceInfo('project', profileName, projectId, region);
 }

package/src/cmd/cloud/sandbox/cp.ts

@@ -3,13 +3,14 @@ import { readFileSync, writeFileSync, mkdirSync, statSync, readdirSync } from 'n
 import { dirname, resolve, basename, join, relative } from 'node:path';
 import { createCommand } from '../../../types';
 import * as tui from '../../../tui';
-import { getSandboxRegion, createSandboxClient } from './util';
+import { createSandboxClient } from './util';
 import { getCommand } from '../../../command-prefix';
 import {
 	sandboxWriteFiles,
 	sandboxReadFile,
 	sandboxExecute,
 	executionGet,
+	sandboxResolve,
 	type APIClient,
 } from '@agentuity/server';
 import type { Logger, FileToWrite } from '@agentuity/core';
@@ -47,7 +48,7 @@ export const cpSubcommand = createCommand({
 	aliases: ['copy'],
 	description: 'Copy files or directories to or from a sandbox',
 	tags: ['slow', 'requires-auth'],
-	requires: { auth: true, org: true },
+	requires: { auth: true, apiClient: true },
 	examples: [
 		{
 			command: getCommand('cloud sandbox cp ./local-file.txt snbx_abc123:/path/to/file.txt'),
@@ -84,7 +85,7 @@ export const cpSubcommand = createCommand({
 	},
 
 	async handler(ctx) {
-		const { args, opts, options, auth, logger, orgId, config } = ctx;
+		const { args, opts, options, auth, logger, apiClient } = ctx;
 
 		const source = parsePath(args.source);
 		const destination = parsePath(args.destination);
@@ -102,7 +103,11 @@ export const cpSubcommand = createCommand({
 		}
 
 		const sandboxId = source.sandboxId ?? destination.sandboxId!;
-		const region = await getSandboxRegion(logger, auth, config?.name, sandboxId, orgId);
+
+		// Resolve sandbox to get region and orgId using CLI API
+		const sandboxInfo = await sandboxResolve(apiClient, sandboxId);
+		const { region, orgId } = sandboxInfo;
+
 		const client = createSandboxClient(logger, auth, region);
 		const recursive = opts.recursive ?? false;
 

package/src/cmd/cloud/sandbox/create.ts

@@ -147,7 +147,7 @@ export const createSubcommand = createCommand({
 			}
 		}
 
-		const files = parseFileArgs(opts.file);
+		const files = await parseFileArgs(opts.file);
 		const hasFiles = files.length > 0;
 
 		let metadata: Record<string, unknown> | undefined;
@@ -185,7 +185,7 @@ export const createSubcommand = createCommand({
 						: undefined,
 				timeout: opts.idleTimeout ? { idle: opts.idleTimeout } : undefined,
 				env: Object.keys(envMap).length > 0 ? envMap : undefined,
-				command: hasFiles ? { exec: [], files } : undefined,
+				files: hasFiles ? files : undefined,
 				snapshot: opts.snapshot,
 				dependencies: opts.dependency,
 				metadata,