@agentuity/cli 0.0.105 → 0.0.106

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

@@ -0,0 +1,188 @@
+import { z } from 'zod';
+import { createCommand } from '../../../../types';
+import * as tui from '../../../../tui';
+import { createSandboxClient } from '../util';
+import { getCommand } from '../../../../command-prefix';
+import { snapshotGet, sandboxList } from '@agentuity/server';
+import type { SnapshotFileInfo } from '@agentuity/server';
+import type { SandboxInfo } from '@agentuity/core';
+
+const SnapshotFileSchema = z.object({
+	path: z.string(),
+	size: z.number(),
+});
+
+const SandboxInfoSchema = z.object({
+	sandboxId: z.string().describe('Sandbox ID'),
+	status: z.string().describe('Current status'),
+	createdAt: z.string().describe('Creation timestamp'),
+	executions: z.number().describe('Number of executions'),
+});
+
+const SnapshotGetResponseSchema = z.object({
+	snapshotId: z.string().describe('Snapshot ID'),
+	sandboxId: z.string().describe('Source sandbox ID'),
+	tag: z.string().nullable().optional().describe('Snapshot tag'),
+	sizeBytes: z.number().describe('Snapshot size in bytes'),
+	fileCount: z.number().describe('Number of files'),
+	parentSnapshotId: z.string().nullable().optional().describe('Parent snapshot ID'),
+	createdAt: z.string().describe('Creation timestamp'),
+	downloadUrl: z.string().optional().describe('Presigned download URL'),
+	files: z.array(SnapshotFileSchema).optional().describe('Files in snapshot'),
+	sandboxes: z
+		.array(SandboxInfoSchema)
+		.optional()
+		.describe('Attached sandboxes (idle or running)'),
+});
+
+export const getSubcommand = createCommand({
+	name: 'get',
+	aliases: ['info', 'show'],
+	description: 'Get snapshot details',
+	tags: ['slow', 'requires-auth'],
+	requires: { auth: true, region: true, org: true },
+	examples: [
+		{
+			command: getCommand('cloud sandbox snapshot get snp_abc123'),
+			description: 'Get details for a snapshot',
+		},
+	],
+	schema: {
+		args: z.object({
+			snapshotId: z.string().describe('Snapshot ID'),
+		}),
+		response: SnapshotGetResponseSchema,
+	},
+
+	async handler(ctx) {
+		const { args, options, auth, region, logger, orgId } = ctx;
+		const client = createSandboxClient(logger, auth, region);
+
+		const snapshot = await snapshotGet(client, {
+			snapshotId: args.snapshotId,
+			orgId,
+		});
+
+		const sandboxesResult = await sandboxList(client, {
+			orgId,
+			snapshotId: args.snapshotId,
+		});
+
+		const activeSandboxes = sandboxesResult.sandboxes.filter(
+			(s) => s.status === 'idle' || s.status === 'running'
+		);
+
+		if (!options.json) {
+			tui.info(`Snapshot: ${tui.bold(snapshot.snapshotId)}`);
+			console.log(`  ${tui.muted('Sandbox:')} ${snapshot.sandboxId}`);
+			if (snapshot.tag) {
+				console.log(`  ${tui.muted('Tag:')}     ${snapshot.tag}`);
+			}
+			console.log(`  ${tui.muted('Size:')}    ${tui.formatBytes(snapshot.sizeBytes)}`);
+			console.log(`  ${tui.muted('Files:')}   ${snapshot.fileCount}`);
+			console.log(`  ${tui.muted('Created:')} ${snapshot.createdAt}`);
+			if (snapshot.parentSnapshotId) {
+				console.log(`  ${tui.muted('Parent:')}  ${snapshot.parentSnapshotId}`);
+			}
+
+			if (snapshot.files && snapshot.files.length > 0) {
+				console.log('');
+				tui.info('Files:');
+				printFileTree(snapshot.files);
+			}
+
+			if (activeSandboxes.length > 0) {
+				console.log('');
+				tui.info(`Attached Sandboxes (${activeSandboxes.length}):`);
+				printSandboxTree(activeSandboxes);
+			}
+		}
+
+		return {
+			...snapshot,
+			sandboxes: activeSandboxes.map((s) => ({
+				sandboxId: s.sandboxId,
+				status: s.status,
+				createdAt: s.createdAt,
+				executions: s.executions,
+			})),
+		};
+	},
+});
+
+interface TreeNode {
+	name: string;
+	size?: number;
+	isFile: boolean;
+	children: Map<string, TreeNode>;
+}
+
+function buildFileTree(files: SnapshotFileInfo[]): TreeNode {
+	const root: TreeNode = { name: '', isFile: false, children: new Map() };
+
+	for (const file of files) {
+		const parts = file.path.split('/');
+		let current = root;
+
+		for (let i = 0; i < parts.length; i++) {
+			const part = parts[i];
+			if (!current.children.has(part)) {
+				current.children.set(part, {
+					name: part,
+					isFile: i === parts.length - 1,
+					children: new Map(),
+				});
+			}
+			current = current.children.get(part)!;
+
+			if (i === parts.length - 1) {
+				current.size = file.size;
+				current.isFile = true;
+			}
+		}
+	}
+
+	return root;
+}
+
+function printFileTree(files: SnapshotFileInfo[]): void {
+	const tree = buildFileTree(files);
+	printTreeNode(tree, '  ');
+}
+
+function printTreeNode(node: TreeNode, prefix: string): void {
+	const entries = Array.from(node.children.entries()).sort((a, b) => {
+		const aIsDir = !a[1].isFile;
+		const bIsDir = !b[1].isFile;
+		if (aIsDir !== bIsDir) return aIsDir ? -1 : 1;
+		return a[0].localeCompare(b[0]);
+	});
+
+	for (let i = 0; i < entries.length; i++) {
+		const [, child] = entries[i];
+		const isLast = i === entries.length - 1;
+		const connector = tui.muted(isLast ? '└── ' : '├── ');
+		const sizeStr =
+			child.isFile && child.size !== undefined ? ` (${tui.formatBytes(child.size)})` : '';
+
+		console.log(`${prefix}${connector}${child.name}${sizeStr}`);
+
+		if (child.children.size > 0) {
+			const newPrefix = prefix + (isLast ? '    ' : tui.muted('│   '));
+			printTreeNode(child, newPrefix);
+		}
+	}
+}
+
+function printSandboxTree(sandboxes: SandboxInfo[]): void {
+	const sorted = [...sandboxes].sort((a, b) => a.sandboxId.localeCompare(b.sandboxId));
+	for (let i = 0; i < sorted.length; i++) {
+		const sandbox = sorted[i];
+		const isLast = i === sorted.length - 1;
+		const connector = tui.muted(isLast ? '└── ' : '├── ');
+		const statusColor = sandbox.status === 'running' ? tui.success : tui.muted;
+		console.log(`  ${connector}${sandbox.sandboxId} ${statusColor(`(${sandbox.status})`)}`);
+	}
+}
+
+export default getSubcommand;

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

@@ -0,0 +1,28 @@
+import { createCommand } from '../../../../types';
+import { createSubcommand } from './create';
+import { listSubcommand } from './list';
+import { getSubcommand } from './get';
+import { deleteSubcommand } from './delete';
+import { tagSubcommand } from './tag';
+import { getCommand } from '../../../../command-prefix';
+
+export const snapshotCommand = createCommand({
+	name: 'snapshot',
+	aliases: ['snap'],
+	description: 'Manage sandbox snapshots',
+	tags: ['slow', 'requires-auth'],
+	examples: [
+		{
+			command: getCommand('cloud sandbox snapshot create <sandbox-id>'),
+			description: 'Create a snapshot from a sandbox',
+		},
+		{
+			command: getCommand('cloud sandbox snapshot list'),
+			description: 'List all snapshots',
+		},
+	],
+	subcommands: [createSubcommand, listSubcommand, getSubcommand, deleteSubcommand, tagSubcommand],
+	requires: { auth: true, region: true, org: true },
+});
+
+export default snapshotCommand;

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');