@agentuity/cli 0.0.104 → 0.0.106

package/src/cmd/cloud/sandbox/snapshot/list.ts

@@ -0,0 +1,90 @@
+import { z } from 'zod';
+import { createCommand } from '../../../../types';
+import * as tui from '../../../../tui';
+import { createSandboxClient } from '../util';
+import { getCommand } from '../../../../command-prefix';
+import { snapshotList } from '@agentuity/server';
+
+const SnapshotInfoSchema = z.object({
+	snapshotId: z.string(),
+	sandboxId: z.string(),
+	tag: z.string().nullable().optional(),
+	sizeBytes: z.number(),
+	fileCount: z.number(),
+	parentSnapshotId: z.string().nullable().optional(),
+	createdAt: z.string(),
+});
+
+const SnapshotListResponseSchema = z.object({
+	snapshots: z.array(SnapshotInfoSchema).describe('List of snapshots'),
+	total: z.number().describe('Total number of snapshots'),
+});
+
+export const listSubcommand = createCommand({
+	name: 'list',
+	aliases: ['ls'],
+	description: 'List snapshots',
+	tags: ['slow', 'requires-auth'],
+	requires: { auth: true, region: true, org: true },
+	examples: [
+		{
+			command: getCommand('cloud sandbox snapshot list'),
+			description: 'List all snapshots',
+		},
+		{
+			command: getCommand('cloud sandbox snapshot list --sandbox sbx_abc123'),
+			description: 'List snapshots for a specific sandbox',
+		},
+	],
+	schema: {
+		options: z.object({
+			sandbox: z.string().optional().describe('Filter by sandbox ID'),
+			limit: z.number().optional().describe('Maximum number of results'),
+			offset: z.number().optional().describe('Offset for pagination'),
+		}),
+		response: SnapshotListResponseSchema,
+	},
+
+	async handler(ctx) {
+		const { opts, options, auth, region, logger, orgId } = ctx;
+		const client = createSandboxClient(logger, auth, region);
+
+		const result = await snapshotList(client, {
+			sandboxId: opts.sandbox,
+			limit: opts.limit,
+			offset: opts.offset,
+			orgId,
+		});
+
+		if (!options.json) {
+			if (result.snapshots.length === 0) {
+				tui.info('No snapshots found');
+			} else {
+				const tableData = result.snapshots.map((snap) => {
+					return {
+						ID: snap.snapshotId,
+						Tag: snap.tag ?? '-',
+						Sandbox: snap.sandboxId,
+						Size: tui.formatBytes(snap.sizeBytes),
+						Files: snap.fileCount,
+						'Created At': snap.createdAt,
+					};
+				});
+				tui.table(tableData, [
+					{ name: 'ID', alignment: 'left' },
+					{ name: 'Tag', alignment: 'left' },
+					{ name: 'Sandbox', alignment: 'left' },
+					{ name: 'Size', alignment: 'right' },
+					{ name: 'Files', alignment: 'right' },
+					{ name: 'Created At', alignment: 'left' },
+				]);
+
+				tui.info(`Total: ${result.total} ${tui.plural(result.total, 'snapshot', 'snapshots')}`);
+			}
+		}
+
+		return result;
+	},
+});
+
+export default listSubcommand;

package/src/cmd/cloud/sandbox/snapshot/tag.ts

@@ -0,0 +1,70 @@
+import { z } from 'zod';
+import { createCommand } from '../../../../types';
+import * as tui from '../../../../tui';
+import { createSandboxClient } from '../util';
+import { getCommand } from '../../../../command-prefix';
+import { snapshotTag } from '@agentuity/server';
+
+const SnapshotTagResponseSchema = z.object({
+	snapshotId: z.string().describe('Snapshot ID'),
+	tag: z.string().nullable().optional().describe('New tag'),
+});
+
+export const tagSubcommand = createCommand({
+	name: 'tag',
+	description: 'Add or update a tag on a snapshot',
+	tags: ['slow', 'requires-auth'],
+	requires: { auth: true, region: true, org: true },
+	examples: [
+		{
+			command: getCommand('cloud sandbox snapshot tag snp_abc123 latest'),
+			description: 'Tag a snapshot as "latest"',
+		},
+		{
+			command: getCommand('cloud sandbox snapshot tag snp_abc123 --clear'),
+			description: 'Remove a tag from a snapshot',
+		},
+	],
+	schema: {
+		args: z.object({
+			snapshotId: z.string().describe('Snapshot ID to tag'),
+			tag: z.string().optional().describe('Tag name to apply'),
+		}),
+		options: z.object({
+			clear: z.boolean().optional().describe('Remove the tag from the snapshot'),
+		}),
+		response: SnapshotTagResponseSchema,
+	},
+
+	async handler(ctx) {
+		const { args, opts, options, auth, region, logger, orgId } = ctx;
+		const client = createSandboxClient(logger, auth, region);
+
+		if (!args.tag && !opts.clear) {
+			throw new Error('Either provide a tag name or use --clear to remove the tag');
+		}
+
+		const tag = opts.clear ? null : (args.tag ?? null);
+
+		const snapshot = await snapshotTag(client, {
+			snapshotId: args.snapshotId,
+			tag,
+			orgId,
+		});
+
+		if (!options.json) {
+			if (tag) {
+				tui.success(`tagged snapshot ${tui.bold(snapshot.snapshotId)} as ${tui.bold(tag)}`);
+			} else {
+				tui.success(`removed tag from snapshot ${tui.bold(snapshot.snapshotId)}`);
+			}
+		}
+
+		return {
+			snapshotId: snapshot.snapshotId,
+			tag: snapshot.tag,
+		};
+	},
+});
+
+export default tagSubcommand;

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

@@ -0,0 +1,59 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import type { Logger, FileToWrite } from '@agentuity/core';
+import { APIClient, getServiceUrls } from '@agentuity/server';
+import type { AuthData } from '../../../types';
+
+export function createSandboxClient(logger: Logger, auth: AuthData, region: string): APIClient {
+	const urls = getServiceUrls(region);
+	return new APIClient(urls.catalyst, logger, auth.apiKey);
+}
+
+/**
+ * Parse --file arguments and read file contents.
+ *
+ * Formats:
+ * - <sandbox-path>:<local-path>  - explicit mapping (e.g., script.js:./local/script.js)
+ * - <filename>                   - shorthand, uses same name for both (e.g., script.js -> script.js:./script.js)
+ *
+ * @returns Array of FileToWrite objects
+ */
+export function parseFileArgs(fileArgs: string[] | undefined): FileToWrite[] {
+	if (!fileArgs || fileArgs.length === 0) {
+		return [];
+	}
+
+	const files: FileToWrite[] = [];
+
+	for (const arg of fileArgs) {
+		let sandboxPath: string;
+		let localPath: string;
+
+		const colonIndex = arg.indexOf(':');
+		if (colonIndex === -1) {
+			// Shorthand: just filename, use same name for sandbox and look in current dir
+			sandboxPath = arg;
+			localPath = `./${arg}`;
+		} else {
+			sandboxPath = arg.slice(0, colonIndex);
+			localPath = arg.slice(colonIndex + 1);
+
+			if (!sandboxPath) {
+				throw new Error(`Invalid --file format: "${arg}". Sandbox path cannot be empty`);
+			}
+			if (!localPath) {
+				throw new Error(`Invalid --file format: "${arg}". Local path cannot be empty`);
+			}
+		}
+
+		const resolvedPath = resolve(localPath);
+		if (!existsSync(resolvedPath)) {
+			throw new Error(`File not found: ${localPath} (resolved to ${resolvedPath})`);
+		}
+
+		const content = readFileSync(resolvedPath);
+		files.push({ path: sandboxPath, content });
+	}
+
+	return files;
+}

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

@@ -2,7 +2,12 @@ import { z } from 'zod';
 import { createSubcommand } from '../../../types';
 import * as tui from '../../../tui';
 import { projectEnvDelete } from '@agentuity/server';
-import { findEnvFile, readEnvFile, writeEnvFile, filterAgentuitySdkKeys } from '../../../env-util';
+import {
+	findExistingEnvFile,
+	readEnvFile,
+	writeEnvFile,
+	filterAgentuitySdkKeys,
+} from '../../../env-util';
 import { getCommand } from '../../../command-prefix';
 
 const SecretDeleteResponseSchema = z.object({
@@ -40,8 +45,8 @@ export const deleteSubcommand = createSubcommand({
 			});
 		});
 
-		// Update local .env.production file
-		const envFilePath = await findEnvFile(projectDir);
+		// Update local .env file
+		const envFilePath = await findExistingEnvFile(projectDir);
 		const currentEnv = await readEnvFile(envFilePath);
 		delete currentEnv[args.key];
 

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

@@ -3,7 +3,7 @@ import { createSubcommand } from '../../../types';
 import * as tui from '../../../tui';
 import { projectEnvUpdate } from '@agentuity/server';
 import {
-	findEnvFile,
+	findExistingEnvFile,
 	readEnvFile,
 	writeEnvFile,
 	filterAgentuitySdkKeys,
@@ -21,7 +21,7 @@ const SecretImportResponseSchema = z.object({
 
 export const importSubcommand = createSubcommand({
 	name: 'import',
-	description: 'Import secrets from a file to cloud and local .env.production',
+	description: 'Import secrets from a file to cloud and local .env',
 	tags: [
 		'mutating',
 		'creates-resource',
@@ -33,8 +33,8 @@ export const importSubcommand = createSubcommand({
 	examples: [
 		{ command: getCommand('secret import .env.local'), description: 'Run .env.local command' },
 		{
-			command: getCommand('secret import .env.production.backup'),
-			description: 'Run .env.production.backup command',
+			command: getCommand('secret import .env.backup'),
+			description: 'Run .env.backup command',
 		},
 	],
 	idempotent: false,
@@ -85,8 +85,8 @@ export const importSubcommand = createSubcommand({
 			});
 		});
 
-		// Merge with local .env.production file
-		const localEnvPath = await findEnvFile(projectDir);
+		// Merge with local .env file
+		const localEnvPath = await findExistingEnvFile(projectDir);
 		const localEnv = await readEnvFile(localEnvPath);
 		const mergedEnv = mergeEnvVars(localEnv, filteredSecrets);
 

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

@@ -10,6 +10,7 @@ import { getCommand } from '../../../command-prefix';
 
 export const command = createCommand({
 	name: 'secret',
+	aliases: ['secrets'],
 	description: 'Manage secrets for your project',
 	tags: ['fast', 'requires-auth', 'requires-project'],
 	examples: [

package/src/cmd/cloud/secret/pull.ts

@@ -3,13 +3,7 @@ import { join } from 'node:path';
 import { createSubcommand } from '../../../types';
 import * as tui from '../../../tui';
 import { projectGet } from '@agentuity/server';
-import {
-	findEnvFile,
-	findExistingEnvFile,
-	readEnvFile,
-	writeEnvFile,
-	mergeEnvVars,
-} from '../../../env-util';
+import { findExistingEnvFile, readEnvFile, writeEnvFile, mergeEnvVars } from '../../../env-util';
 import { getCommand } from '../../../command-prefix';
 
 const SecretPullResponseSchema = z.object({
@@ -21,7 +15,7 @@ const SecretPullResponseSchema = z.object({
 
 export const pullSubcommand = createSubcommand({
 	name: 'pull',
-	description: 'Pull secrets from cloud to local .env.production file',
+	description: 'Pull secrets from cloud to local .env file',
 	tags: ['slow', 'requires-auth', 'requires-project'],
 	idempotent: true,
 	examples: [
@@ -45,14 +39,11 @@ export const pullSubcommand = createSubcommand({
 			return projectGet(apiClient, { id: project.projectId, mask: false });
 		});
 
-		const cloudSecrets = projectData.secrets || {};
+		const cloudSecrets = { ...projectData.env, ...projectData.secrets }; // secret pull with actually do both secrets and env since thats likely what the user would want
 
-		// Read current local env from existing file (.env.production or .env)
-		const existingEnvPath = await findExistingEnvFile(projectDir);
-		const localEnv = await readEnvFile(existingEnvPath);
-
-		// Target file is always .env.production
-		const targetEnvPath = await findEnvFile(projectDir);
+		// Target file is always .env
+		const targetEnvPath = await findExistingEnvFile(projectDir);
+		const localEnv = await readEnvFile(targetEnvPath);
 
 		// Merge: cloud values override local if force=true, otherwise keep local
 		let mergedEnv: Record<string, string>;
@@ -64,7 +55,7 @@ export const pullSubcommand = createSubcommand({
 			mergedEnv = mergeEnvVars(cloudSecrets, localEnv);
 		}
 
-		// Write to .env.production (skip AGENTUITY_ keys)
+		// Write to .env (skip AGENTUITY_ keys)
 		await writeEnvFile(targetEnvPath, mergedEnv, {
 			skipKeys: Object.keys(mergedEnv).filter((k) => k.startsWith('AGENTUITY_')),
 		});

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

@@ -2,7 +2,7 @@ import { z } from 'zod';
 import { createSubcommand } from '../../../types';
 import * as tui from '../../../tui';
 import { projectEnvUpdate } from '@agentuity/server';
-import { findEnvFile, readEnvFile, filterAgentuitySdkKeys } from '../../../env-util';
+import { findExistingEnvFile, readEnvFile, filterAgentuitySdkKeys } from '../../../env-util';
 import { getCommand } from '../../../command-prefix';
 
 const SecretPushResponseSchema = z.object({
@@ -13,7 +13,7 @@ const SecretPushResponseSchema = z.object({
 
 export const pushSubcommand = createSubcommand({
 	name: 'push',
-	description: 'Push secrets from local .env.production file to cloud',
+	description: 'Push secrets from local .env file to cloud',
 	tags: [
 		'mutating',
 		'updates-resource',
@@ -34,7 +34,7 @@ export const pushSubcommand = createSubcommand({
 		const { apiClient, project, projectDir } = ctx;
 
 		// Read local env file
-		const envFilePath = await findEnvFile(projectDir);
+		const envFilePath = await findExistingEnvFile(projectDir);
 		const localEnv = await readEnvFile(envFilePath);
 
 		// Filter out AGENTUITY_ prefixed keys (don't push SDK keys)

package/src/cmd/cloud/secret/set.ts

@@ -2,7 +2,12 @@ import { z } from 'zod';
 import { createSubcommand } from '../../../types';
 import * as tui from '../../../tui';
 import { projectEnvUpdate } from '@agentuity/server';
-import { findEnvFile, readEnvFile, writeEnvFile, filterAgentuitySdkKeys } from '../../../env-util';
+import {
+	findExistingEnvFile,
+	readEnvFile,
+	writeEnvFile,
+	filterAgentuitySdkKeys,
+} from '../../../env-util';
 import { getCommand } from '../../../command-prefix';
 
 const SecretSetResponseSchema = z.object({
@@ -51,8 +56,8 @@ export const setSubcommand = createSubcommand({
 			});
 		});
 
-		// Update local .env.production file
-		const envFilePath = await findEnvFile(projectDir);
+		// Update local .env file
+		const envFilePath = await findExistingEnvFile(projectDir);
 		const currentEnv = await readEnvFile(envFilePath);
 		currentEnv[args.key] = args.value;
 

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

@@ -5,6 +5,7 @@ import * as tui from '../../../tui';
 import { getCatalystAPIClient } from '../../../config';
 import { getCommand } from '../../../command-prefix';
 import { isDryRunMode, outputDryRun } from '../../../explain';
+import { addResourceEnvVars } from '../../../env-util';
 
 export const createSubcommand = defineSubcommand({
 	name: 'create',
@@ -62,10 +63,22 @@ export const createSubcommand = defineSubcommand({
 		});
 
 		if (created.length > 0) {
-			tui.success(`Created storage: ${tui.bold(created[0].name)}`);
+			const resource = created[0];
+
+			// 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 storage: ${tui.bold(resource.name)}`);
+			}
 			return {
 				success: true,
-				name: created[0].name,
+				name: resource.name,
 			};
 		} else {
 			tui.fatal('Failed to create storage');

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

@@ -8,6 +8,7 @@ import { getCommand } from '../../../command-prefix';
 import { isDryRunMode, outputDryRun } from '../../../explain';
 import { ErrorCode } from '../../../errors';
 import { createS3Client } from './utils';
+import { removeResourceEnvVars } from '../../../env-util';
 
 export const deleteSubcommand = createSubcommand({
 	name: 'delete',
@@ -194,10 +195,22 @@ export const deleteSubcommand = createSubcommand({
 		});
 
 		if (deleted.length > 0) {
-			tui.success(`Deleted storage bucket: ${tui.bold(deleted[0])}`);
+			const resource = deleted[0];
+
+			// 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 storage bucket: ${tui.bold(resource.name)}`);
+			}
 			return {
 				success: true,
-				name: deleted[0],
+				name: resource.name,
 			};
 		} else {
 			tui.error('Failed to delete storage bucket');

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

@@ -3,13 +3,6 @@ import { createCommand } from '../../../types';
 import * as tui from '../../../tui';
 import { createStorageAdapter } from './util';
 import { getCommand } from '../../../command-prefix';
-function formatBytes(bytes: number): string {
-	if (bytes === 0) return '0 B';
-	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`;
-}
 
 const StreamInfoSchema = z.object({
 	id: z.string().describe('Stream ID'),
@@ -124,7 +117,7 @@ export const listSubcommand = createCommand({
 				return {
 					Name: stream.name,
 					ID: stream.id,
-					Size: formatBytes(sizeBytes),
+					Size: tui.formatBytes(sizeBytes),
 					Metadata:
 						metadataStr.length > 40 ? metadataStr.substring(0, 37) + '...' : metadataStr,
 					URL: tui.link(stream.url),
@@ -139,7 +132,7 @@ export const listSubcommand = createCommand({
 				{ name: 'URL', alignment: 'left' },
 			]);
 
-			tui.info(`Total: ${result.total} stream(s)`);
+			tui.info(`Total: ${result.total} ${tui.plural(result.total, 'stream', 'streams')}`);
 		}
 
 		return {

package/src/cmd/dev/index.ts

@@ -12,7 +12,7 @@ import { APIClient, getAPIBaseURL, getAppBaseURL, getGravityDevModeURL } from '.
 import { download } from './download';
 import { createDevmodeSyncService } from './sync';
 import { getDevmodeDeploymentId } from '../build/ast';
-import { getDefaultConfigDir, saveConfig } from '../../config';
+import { getDefaultConfigDir, saveConfig, loadProjectSDKKey } from '../../config';
 import type { Config } from '../../types';
 import { createFileWatcher } from './file-watcher';
 import { regenerateSkillsAsync } from './skills';
@@ -709,6 +709,22 @@ export const command = createCommand({
 				// These must be set so the bundled patches can route LLM calls through AI Gateway
 				const serviceUrls = getServiceUrls(project?.region);
 
+				// Load SDK key from project .env files for AI Gateway routing
+				// This must be set so the bundled AI SDK patches can inject the API key
+				if (!process.env.AGENTUITY_SDK_KEY) {
+					const sdkKey = await loadProjectSDKKey(logger, rootDir);
+					if (sdkKey) {
+						process.env.AGENTUITY_SDK_KEY = sdkKey;
+					} else if (project) {
+						tui.warn(
+							'AGENTUITY_SDK_KEY not found in .env file. Numerous features will be unavailable.'
+						);
+						tui.bullet(
+							`Run "${getCommand('cloud env pull')}" to sync your SDK key, or add AGENTUITY_SDK_KEY to your .env file.`
+						);
+					}
+				}
+
 				process.env.AGENTUITY_SDK_DEV_MODE = 'true';
 				process.env.AGENTUITY_ENV = 'development';
 				process.env.NODE_ENV = 'development';
@@ -723,6 +739,7 @@ export const command = createCommand({
 					process.env.AGENTUITY_CATALYST_URL = serviceUrls.catalyst;
 					process.env.AGENTUITY_VECTOR_URL = serviceUrls.vector;
 					process.env.AGENTUITY_KEYVALUE_URL = serviceUrls.keyvalue;
+					process.env.AGENTUITY_SANDBOX_URL = serviceUrls.sandbox;
 					process.env.AGENTUITY_STREAM_URL = serviceUrls.stream;
 					process.env.AGENTUITY_CLOUD_ORG_ID = project.orgId;
 					process.env.AGENTUITY_CLOUD_PROJECT_ID = project.projectId;

package/src/cmd/profile/create.ts

@@ -79,6 +79,7 @@ export const createCommand = createSubcommand({
 					app_url: 'https://app.agentuity.io',
 					transport_url: 'https://catalyst.agentuity.io',
 					stream_url: 'https://streams.agentuity.io',
+					sandbox_url: 'https://catalyst.agentuity.io',
 					kv_url: 'https://catalyst.agentuity.io',
 					vector_url: 'https://catalyst.agentuity.io',
 					catalyst_url: 'https://catalyst.agentuity.io',

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

@@ -1,5 +1,4 @@
 import { basename, resolve } from 'node:path';
-import { z } from 'zod';
 import { existsSync, readdirSync, rmSync, statSync } from 'node:fs';
 import { cwd } from 'node:process';
 import { homedir } from 'node:os';
@@ -10,7 +9,6 @@ import {
 	projectEnvUpdate,
 	getServiceUrls,
 	APIClient as ServerAPIClient,
-	Resources,
 	createResources,
 } from '@agentuity/server';
 import type { Logger } from '@agentuity/core';
@@ -24,15 +22,15 @@ import { ErrorCode } from '../../errors';
 import type { APIClient } from '../../api';
 import { createProjectConfig } from '../../config';
 import {
-	findEnvFile,
+	findExistingEnvFile,
 	readEnvFile,
 	filterAgentuitySdkKeys,
 	splitEnvAndSecrets,
+	addResourceEnvVars,
+	type EnvVars,
 } from '../../env-util';
 import { promptForDNS } from '../../domain';
 
-type ResourcesTypes = z.infer<typeof Resources>;
-
 interface CreateFlowOptions {
 	projectName?: string;
 	dir?: string;
@@ -252,8 +250,8 @@ export async function runCreateFlow(options: CreateFlowOptions): Promise<void> {
 		}
 	}
 
-	const resourceConfig: ResourcesTypes = Resources.parse({});
 	let _domains = domains;
+	const resourceEnvVars: EnvVars = {};
 
 	if (auth && apiClient && catalystClient && orgId && region && !skipPrompts) {
 		// Fetch resources for selected org and region using Catalyst API
@@ -317,14 +315,21 @@ export async function runCreateFlow(options: CreateFlowOptions): Promise<void> {
 						return createResources(catalystClient, orgId, region!, [{ type: 's3' }]);
 					},
 				});
-				resourceConfig.storage = created[0].name;
+				// Collect env vars from newly created resource
+				if (created[0]?.env) {
+					Object.assign(resourceEnvVars, created[0].env);
+				}
 				break;
 			}
 			case 'Skip': {
 				break;
 			}
 			default: {
-				resourceConfig.storage = choices.s3_action;
+				// User selected an existing bucket - get env vars from the resources list
+				const selectedBucket = resources.s3.find((b) => b.bucket_name === choices.s3_action);
+				if (selectedBucket?.env) {
+					Object.assign(resourceEnvVars, selectedBucket.env);
+				}
 				break;
 			}
 		}
@@ -337,14 +342,21 @@ export async function runCreateFlow(options: CreateFlowOptions): Promise<void> {
 						return createResources(catalystClient, orgId, region!, [{ type: 'db' }]);
 					},
 				});
-				resourceConfig.db = created[0].name;
+				// Collect env vars from newly created resource
+				if (created[0]?.env) {
+					Object.assign(resourceEnvVars, created[0].env);
+				}
 				break;
 			}
 			case 'Skip': {
 				break;
 			}
 			default: {
-				resourceConfig.db = choices.db_action;
+				// User selected an existing database - get env vars from the resources list
+				const selectedDb = resources.db.find((d) => d.name === choices.db_action);
+				if (selectedDb?.env) {
+					Object.assign(resourceEnvVars, selectedDb.env);
+				}
 				break;
 			}
 		}
@@ -384,7 +396,6 @@ export async function runCreateFlow(options: CreateFlowOptions): Promise<void> {
 					orgId,
 					sdkKey: project.sdkKey,
 					deployment: {
-						resources: resourceConfig,
 						domains: _domains,
 					},
 					region: cloudRegion,
@@ -392,14 +403,19 @@ export async function runCreateFlow(options: CreateFlowOptions): Promise<void> {
 			},
 		});
 
-		// After registration, push any existing env/secrets from .env.production
+		// Write resource environment variables to .env
+		if (Object.keys(resourceEnvVars).length > 0) {
+			await addResourceEnvVars(dest, resourceEnvVars);
+		}
+
+		// After registration, push any existing env/secrets from .env
 		if (projectId) {
 			await tui.spinner({
 				message: 'Syncing environment variables',
 				clearOnSuccess: true,
 				callback: async () => {
 					try {
-						const envFilePath = await findEnvFile(dest);
+						const envFilePath = await findExistingEnvFile(dest);
 						const localEnv = await readEnvFile(envFilePath);
 						const filteredEnv = filterAgentuitySdkKeys(localEnv);
 

package/src/config.ts

@@ -181,6 +181,9 @@ export async function loadConfig(customPath?: string, skipCache = false): Promis
 			if (process.env.AGENTUITY_KEYVALUE_URL) {
 				overrides.kv_url = process.env.AGENTUITY_KEYVALUE_URL;
 			}
+			if (process.env.AGENTUITY_SANDBOX_URL) {
+				overrides.sandbox_url = process.env.AGENTUITY_SANDBOX_URL;
+			}
 			if (process.env.AGENTUITY_VECTOR_URL) {
 				overrides.vector_url = process.env.AGENTUITY_VECTOR_URL;
 			}