@agentuity/cli 1.0.1 → 1.0.3

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

@@ -1,9 +1,9 @@
 import { z } from 'zod';
 import { createCommand } from '../../../types';
 import * as tui from '../../../tui';
-import { getSandboxRegion, createSandboxClient, clearSandboxRegionCache } from './util';
+import { createSandboxClient, clearSandboxRegionCache } from './util';
 import { getCommand } from '../../../command-prefix';
-import { sandboxDestroy } from '@agentuity/server';
+import { sandboxDestroy, sandboxResolve } from '@agentuity/server';
 
 const SandboxDeleteResponseSchema = z.object({
 	success: z.boolean().describe('Whether the operation succeeded'),
@@ -17,7 +17,7 @@ export const deleteSubcommand = createCommand({
 	aliases: ['del', 'remove', 'destroy'],
 	description: 'Delete a sandbox',
 	tags: ['destructive', 'deletes-resource', 'slow', 'requires-auth'],
-	requires: { auth: true, org: true },
+	requires: { auth: true, apiClient: true },
 	idempotent: true,
 	examples: [
 		{
@@ -40,7 +40,7 @@ export const deleteSubcommand = createCommand({
 	},
 
 	async handler(ctx) {
-		const { args, options, opts, auth, config, logger, orgId } = ctx;
+		const { args, options, opts, auth, config, logger, apiClient } = ctx;
 
 		if (!opts.confirm) {
 			const confirmed = await tui.confirm(`Delete sandbox "${args.sandboxId}"?`, false);
@@ -56,10 +56,13 @@ export const deleteSubcommand = createCommand({
 		}
 
 		const started = Date.now();
-		const region = await getSandboxRegion(logger, auth, config?.name, args.sandboxId, orgId);
-		const client = createSandboxClient(logger, auth, region);
 
-		await sandboxDestroy(client, { sandboxId: args.sandboxId, orgId });
+		// Resolve sandbox to get region and orgId using CLI API
+		const sandboxInfo = await sandboxResolve(apiClient, args.sandboxId);
+
+		const client = createSandboxClient(logger, auth, sandboxInfo.region);
+
+		await sandboxDestroy(client, { sandboxId: args.sandboxId, orgId: sandboxInfo.orgId });
 		const durationMs = Date.now() - started;
 
 		await clearSandboxRegionCache(config?.name, args.sandboxId);

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

@@ -2,16 +2,16 @@ import { z } from 'zod';
 import { writeFileSync } from 'node:fs';
 import { createCommand } from '../../../types';
 import * as tui from '../../../tui';
-import { createSandboxClient, getSandboxRegion } from './util';
+import { createSandboxClient } from './util';
 import { getCommand } from '../../../command-prefix';
-import { sandboxDownloadArchive } from '@agentuity/server';
+import { sandboxDownloadArchive, sandboxResolve } from '@agentuity/server';
 
 export const downloadSubcommand = createCommand({
 	name: 'download',
 	aliases: ['dl'],
 	description: 'Download files from a sandbox as a compressed archive',
 	tags: ['slow', 'requires-auth'],
-	requires: { auth: true, org: true },
+	requires: { auth: true, apiClient: true },
 	examples: [
 		{
 			command: getCommand('cloud sandbox download sbx_abc123 ./backup.tar.gz'),
@@ -46,9 +46,12 @@ export const downloadSubcommand = createCommand({
 	},
 
 	async handler(ctx) {
-		const { args, opts, options, auth, logger, orgId, config } = ctx;
+		const { args, opts, options, auth, logger, apiClient } = ctx;
+
+		// Resolve sandbox to get region and orgId using CLI API
+		const sandboxInfo = await sandboxResolve(apiClient, args.sandboxId);
+		const { region, orgId } = sandboxInfo;
 
-		const region = await getSandboxRegion(logger, auth, config?.name, args.sandboxId, orgId);
 		const client = createSandboxClient(logger, auth, region);
 
 		const format = opts.format ?? detectFormat(args.output);

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

@@ -1,15 +1,15 @@
 import { z } from 'zod';
 import { createCommand } from '../../../types';
 import * as tui from '../../../tui';
-import { getSandboxRegion, createSandboxClient } from './util';
+import { createSandboxClient } from './util';
 import { getCommand } from '../../../command-prefix';
-import { sandboxSetEnv } from '@agentuity/server';
+import { sandboxSetEnv, sandboxResolve } from '@agentuity/server';
 
 export const envSubcommand = createCommand({
 	name: 'env',
 	description: 'Set or delete environment variables on a sandbox',
 	tags: ['slow', 'requires-auth'],
-	requires: { auth: true, org: true },
+	requires: { auth: true, apiClient: true },
 	examples: [
 		{
 			command: getCommand('cloud sandbox env sbx_abc123 MY_VAR=value'),
@@ -42,9 +42,12 @@ export const envSubcommand = createCommand({
 	},
 
 	async handler(ctx) {
-		const { args, opts, options, auth, config, logger, orgId } = ctx;
+		const { args, opts, options, auth, logger, apiClient } = ctx;
+
+		// Resolve sandbox to get region and orgId using CLI API
+		const sandboxInfo = await sandboxResolve(apiClient, args.sandboxId);
+		const { region, orgId } = sandboxInfo;
 
-		const region = await getSandboxRegion(logger, auth, config?.name, args.sandboxId, orgId);
 		const client = createSandboxClient(logger, auth, region);
 
 		const envMap: Record<string, string | null> = {};

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

@@ -2,9 +2,9 @@ import { z } from 'zod';
 import { Writable } from 'node:stream';
 import { createCommand } from '../../../types';
 import * as tui from '../../../tui';
-import { getSandboxRegion, createSandboxClient } from './util';
+import { createSandboxClient } from './util';
 import { getCommand } from '../../../command-prefix';
-import { sandboxExecute, executionGet, writeAndDrain } from '@agentuity/server';
+import { sandboxExecute, executionGet, writeAndDrain, sandboxResolve } from '@agentuity/server';
 import type { Logger } from '@agentuity/core';
 
 // Server-side long-poll wait duration (max 5 minutes supported by server)
@@ -23,7 +23,7 @@ export const execSubcommand = createCommand({
 	aliases: ['execute'],
 	description: 'Execute a command in a running sandbox',
 	tags: ['slow', 'requires-auth'],
-	requires: { auth: true, org: true },
+	requires: { auth: true, apiClient: true },
 	examples: [
 		{
 			command: getCommand('cloud sandbox exec abc123 -- echo "hello"'),
@@ -34,6 +34,7 @@ export const execSubcommand = createCommand({
 			description: 'Execute with timeout',
 		},
 	],
+
 	schema: {
 		args: z.object({
 			sandboxId: z.string().describe('Sandbox ID'),
@@ -51,8 +52,12 @@ export const execSubcommand = createCommand({
 	},
 
 	async handler(ctx) {
-		const { args, opts, options, auth, config, logger, orgId } = ctx;
-		const region = await getSandboxRegion(logger, auth, config?.name, args.sandboxId, orgId);
+		const { args, opts, options, auth, logger, apiClient } = ctx;
+
+		// Resolve sandbox to get region and orgId using CLI API
+		const sandboxInfo = await sandboxResolve(apiClient, args.sandboxId);
+		const { region, orgId } = sandboxInfo;
+
 		const client = createSandboxClient(logger, auth, region);
 		const started = Date.now();
 

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

@@ -1,10 +1,9 @@
 import { z } from 'zod';
 import { createCommand } from '../../../types';
 import * as tui from '../../../tui';
-import { cacheSandboxRegion } from './util';
+import { cacheSandboxRegion, createSandboxClient } from './util';
 import { getCommand } from '../../../command-prefix';
-import { sandboxGet } from '@agentuity/server';
-import { getGlobalCatalystAPIClient } from '../../../config';
+import { sandboxGet, sandboxResolve } from '@agentuity/server';
 
 const SandboxResourcesSchema = z.object({
 	memory: z.string().optional().describe('Memory limit (e.g., "512Mi", "1Gi")'),
@@ -51,7 +50,7 @@ export const getSubcommand = createCommand({
 	aliases: ['info', 'show'],
 	description: 'Get information about a sandbox',
 	tags: ['read-only', 'fast', 'requires-auth'],
-	requires: { auth: true, org: true },
+	requires: { auth: true, apiClient: true },
 	idempotent: true,
 	examples: [
 		{
@@ -67,10 +66,17 @@ export const getSubcommand = createCommand({
 	},
 
 	async handler(ctx) {
-		const { args, options, auth, logger, orgId, config } = ctx;
-		const client = await getGlobalCatalystAPIClient(logger, auth, config?.name);
+		const { args, options, auth, logger, config, apiClient } = ctx;
 
-		const result = await sandboxGet(client, { sandboxId: args.sandboxId, orgId });
+		// Resolve sandbox to get region and orgId using CLI API
+		const sandboxInfo = await sandboxResolve(apiClient, args.sandboxId);
+
+		// Create regional client and get full sandbox details
+		const client = createSandboxClient(logger, auth, sandboxInfo.region);
+		const result = await sandboxGet(client, {
+			sandboxId: args.sandboxId,
+			orgId: sandboxInfo.orgId,
+		});
 
 		// Cache the region for future lookups
 		if (result.region) {

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

@@ -2,59 +2,18 @@ import { z } from 'zod';
 import { createCommand } from '../../../types';
 import * as tui from '../../../tui';
 import { getCommand } from '../../../command-prefix';
-import { sandboxList } from '@agentuity/server';
-import { getGlobalCatalystAPIClient } from '../../../config';
-import type { SandboxStatus } from '@agentuity/core';
-
-const SandboxRuntimeInfoSchema = z.object({
-	id: z.string().describe('Runtime ID'),
-	name: z.string().describe('Runtime name'),
-	iconUrl: z.string().optional().describe('URL for runtime icon'),
-	brandColor: z.string().optional().describe('Brand color for the runtime'),
-	tags: z.array(z.string()).optional().describe('Runtime tags'),
-});
-
-const SandboxSnapshotUserInfoSchema = z.object({
-	id: z.string().describe('User ID'),
-	firstName: z.string().optional().describe("User's first name"),
-	lastName: z.string().optional().describe("User's last name"),
-});
-
-const SandboxSnapshotOrgInfoSchema = z.object({
-	id: z.string().describe('Organization ID'),
-	name: z.string().describe('Organization name'),
-	slug: z.string().optional().describe('Organization slug'),
-});
-
-const SandboxSnapshotInfoSchema = z.discriminatedUnion('public', [
-	z.object({
-		id: z.string().describe('Snapshot ID'),
-		name: z.string().optional().describe('Snapshot name'),
-		tag: z.string().nullable().optional().describe('Snapshot tag'),
-		fullName: z.string().optional().describe('Full name with org slug'),
-		public: z.literal(true).describe('Public snapshot'),
-		org: SandboxSnapshotOrgInfoSchema.describe('Organization that owns the public snapshot'),
-	}),
-	z.object({
-		id: z.string().describe('Snapshot ID'),
-		name: z.string().optional().describe('Snapshot name'),
-		tag: z.string().nullable().optional().describe('Snapshot tag'),
-		fullName: z.string().optional().describe('Full name with org slug'),
-		public: z.literal(false).describe('Private snapshot'),
-		user: SandboxSnapshotUserInfoSchema.describe('User who created the private snapshot'),
-	}),
-]);
+import { cliSandboxList } from '@agentuity/server';
 
 const SandboxInfoSchema = z.object({
-	sandboxId: z.string().describe('Sandbox ID'),
-	name: z.string().optional().describe('Sandbox name'),
-	description: z.string().optional().describe('Sandbox description'),
+	id: z.string().describe('Sandbox ID'),
+	name: z.string().nullable().describe('Sandbox name'),
+	description: z.string().nullable().describe('Sandbox description'),
 	status: z.string().describe('Current status'),
-	createdAt: z.string().describe('Creation timestamp'),
-	region: z.string().optional().describe('Region where sandbox is running'),
-	runtime: SandboxRuntimeInfoSchema.optional().describe('Runtime information'),
-	snapshot: SandboxSnapshotInfoSchema.optional().describe('Snapshot information'),
-	executions: z.number().describe('Number of executions'),
+	createdAt: z.string().nullable().describe('Creation timestamp'),
+	region: z.string().nullable().describe('Region where sandbox is running'),
+	orgId: z.string().describe('Organization ID'),
+	orgName: z.string().nullable().describe('Organization name'),
+	projectId: z.string().nullable().describe('Project ID'),
 });
 
 const SandboxListResponseSchema = z.object({
@@ -67,7 +26,7 @@ export const listSubcommand = createCommand({
 	aliases: ['ls'],
 	description: 'List sandboxes with optional filtering',
 	tags: ['read-only', 'slow', 'requires-auth'],
-	requires: { auth: true, org: true },
+	requires: { auth: true, apiClient: true },
 	optional: { project: true },
 	idempotent: true,
 	pagination: {
@@ -92,6 +51,10 @@ export const listSubcommand = createCommand({
 			command: getCommand('cloud sandbox list --project-id proj_123'),
 			description: 'List sandboxes for a specific project',
 		},
+		{
+			command: getCommand('cloud sandbox list --org-id org_123'),
+			description: 'List sandboxes for a specific organization',
+		},
 		{
 			command: getCommand('cloud sandbox list --limit 10 --offset 20'),
 			description: 'List with pagination',
@@ -108,6 +71,7 @@ export const listSubcommand = createCommand({
 				.optional()
 				.describe('Filter by status'),
 			projectId: z.string().optional().describe('Filter by project ID'),
+			orgId: z.string().optional().describe('Filter by organization ID'),
 			all: z.boolean().optional().describe('List all sandboxes regardless of project context'),
 			limit: z.number().optional().describe('Maximum number of results (default: 50, max: 100)'),
 			offset: z.number().optional().describe('Pagination offset'),
@@ -116,57 +80,67 @@ export const listSubcommand = createCommand({
 	},
 
 	async handler(ctx) {
-		const { opts, options, auth, project, logger, orgId, config } = ctx;
-		const client = await getGlobalCatalystAPIClient(logger, auth, config?.name);
+		const { opts, options, project, apiClient } = ctx;
 
 		const projectId = opts.all ? undefined : opts.projectId || project?.projectId;
 
-		const result = await sandboxList(client, {
-			orgId,
+		const result = await cliSandboxList(apiClient, {
 			projectId,
-			status: opts.status as SandboxStatus | undefined,
+			orgId: opts.orgId,
+			status: opts.status,
 			limit: opts.limit,
 			offset: opts.offset,
 		});
 
+		// Check if results span multiple orgs
+		const uniqueOrgIds = new Set(result.sandboxes.map((s) => s.orgId));
+		const showOrgColumn = uniqueOrgIds.size > 1;
+
 		if (!options.json) {
 			if (result.sandboxes.length === 0) {
 				tui.info('No sandboxes found');
 			} else {
 				const tableData = result.sandboxes.map((sandbox) => {
-					return {
-						ID: sandbox.sandboxId,
+					const row: Record<string, string | number> = {
+						ID: sandbox.id,
 						Name: sandbox.name || '-',
-						Runtime: sandbox.runtime?.name || '-',
 						Status: sandbox.status,
-						'Created At': sandbox.createdAt,
-						Executions: sandbox.executions,
+						Region: sandbox.region || '-',
+						'Created At': sandbox.createdAt || '-',
 					};
+					if (showOrgColumn) {
+						row.Organization = sandbox.orgName || sandbox.orgId;
+					}
+					return row;
 				});
-				tui.table(tableData, [
-					{ name: 'ID', alignment: 'left' },
-					{ name: 'Name', alignment: 'left' },
-					{ name: 'Runtime', alignment: 'left' },
-					{ name: 'Status', alignment: 'left' },
-					{ name: 'Created At', alignment: 'left' },
-					{ name: 'Executions', alignment: 'right' },
-				]);
 
+				const columns = [
+					{ name: 'ID', alignment: 'left' as const },
+					{ name: 'Name', alignment: 'left' as const },
+					{ name: 'Status', alignment: 'left' as const },
+					{ name: 'Region', alignment: 'left' as const },
+					{ name: 'Created At', alignment: 'left' as const },
+				];
+				if (showOrgColumn) {
+					columns.push({ name: 'Organization', alignment: 'left' as const });
+				}
+
+				tui.table(tableData, columns);
 				tui.info(`Total: ${result.total} ${tui.plural(result.total, 'sandbox', 'sandboxes')}`);
 			}
 		}
 
 		return {
 			sandboxes: result.sandboxes.map((s) => ({
-				sandboxId: s.sandboxId,
+				id: s.id,
 				name: s.name,
 				description: s.description,
 				status: s.status,
 				createdAt: s.createdAt,
 				region: s.region,
-				runtime: s.runtime,
-				snapshot: s.snapshot,
-				executions: s.executions,
+				orgId: s.orgId,
+				orgName: s.orgName,
+				projectId: s.projectId,
 			})),
 			total: result.total,
 		};

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

@@ -1,9 +1,9 @@
 import { z } from 'zod';
 import { createCommand } from '../../../types';
 import * as tui from '../../../tui';
-import { getSandboxRegion, createSandboxClient } from './util';
+import { createSandboxClient } from './util';
 import { getCommand } from '../../../command-prefix';
-import { sandboxListFiles } from '@agentuity/server';
+import { sandboxListFiles, sandboxResolve } from '@agentuity/server';
 
 const FileInfoSchema = z.object({
 	path: z.string(),
@@ -23,7 +23,7 @@ export const lsSubcommand = createCommand({
 	aliases: ['lsf'],
 	description: 'List files in a sandbox directory',
 	tags: ['slow', 'requires-auth'],
-	requires: { auth: true, org: true },
+	requires: { auth: true, apiClient: true },
 	examples: [
 		{
 			command: getCommand('cloud sandbox files sbx_abc123'),
@@ -61,8 +61,12 @@ export const lsSubcommand = createCommand({
 	},
 
 	async handler(ctx) {
-		const { args, opts, options, auth, config, logger, orgId } = ctx;
-		const region = await getSandboxRegion(logger, auth, config?.name, args.sandboxId, orgId);
+		const { args, opts, options, auth, logger, apiClient } = ctx;
+
+		// Resolve sandbox to get region and orgId using CLI API
+		const sandboxInfo = await sandboxResolve(apiClient, args.sandboxId);
+		const { region, orgId } = sandboxInfo;
+
 		const client = createSandboxClient(logger, auth, region);
 
 		const result = await sandboxListFiles(client, {

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

@@ -1,9 +1,9 @@
 import { z } from 'zod';
 import { createCommand } from '../../../types';
 import * as tui from '../../../tui';
-import { createSandboxClient, getSandboxRegion } from './util';
+import { createSandboxClient } from './util';
 import { getCommand } from '../../../command-prefix';
-import { sandboxMkDir } from '@agentuity/server';
+import { sandboxMkDir, sandboxResolve } from '@agentuity/server';
 
 const MkDirResponseSchema = z.object({
 	success: z.boolean(),
@@ -14,7 +14,7 @@ export const mkdirSubcommand = createCommand({
 	name: 'mkdir',
 	description: 'Create a directory in a sandbox',
 	tags: ['slow', 'requires-auth'],
-	requires: { auth: true, org: true },
+	requires: { auth: true, apiClient: true },
 	examples: [
 		{
 			command: getCommand('cloud sandbox mkdir sbx_abc123 /path/to/dir'),
@@ -44,8 +44,12 @@ export const mkdirSubcommand = createCommand({
 	},
 
 	async handler(ctx) {
-		const { args, opts, options, auth, logger, orgId, config } = ctx;
-		const region = await getSandboxRegion(logger, auth, config?.name, args.sandboxId, orgId);
+		const { args, opts, options, auth, logger, apiClient } = ctx;
+
+		// Resolve sandbox to get region and orgId using CLI API
+		const sandboxInfo = await sandboxResolve(apiClient, args.sandboxId);
+		const { region, orgId } = sandboxInfo;
+
 		const client = createSandboxClient(logger, auth, region);
 
 		await sandboxMkDir(client, {

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

@@ -1,9 +1,9 @@
 import { z } from 'zod';
 import { createCommand } from '../../../types';
 import * as tui from '../../../tui';
-import { getSandboxRegion, createSandboxClient } from './util';
+import { createSandboxClient } from './util';
 import { getCommand } from '../../../command-prefix';
-import { sandboxRmFile } from '@agentuity/server';
+import { sandboxRmFile, sandboxResolve } from '@agentuity/server';
 
 const RmFileResponseSchema = z.object({
 	success: z.boolean(),
@@ -14,7 +14,7 @@ export const rmSubcommand = createCommand({
 	name: 'rm',
 	description: 'Remove a file from a sandbox',
 	tags: ['slow', 'requires-auth'],
-	requires: { auth: true, org: true },
+	requires: { auth: true, apiClient: true },
 	examples: [
 		{
 			command: getCommand('cloud sandbox rm sbx_abc123 /path/to/file.txt'),
@@ -31,8 +31,12 @@ export const rmSubcommand = createCommand({
 	},
 
 	async handler(ctx) {
-		const { args, options, auth, logger, orgId, config } = ctx;
-		const region = await getSandboxRegion(logger, auth, config?.name, args.sandboxId, orgId);
+		const { args, options, auth, logger, apiClient } = ctx;
+
+		// Resolve sandbox to get region and orgId using CLI API
+		const sandboxInfo = await sandboxResolve(apiClient, args.sandboxId);
+		const { region, orgId } = sandboxInfo;
+
 		const client = createSandboxClient(logger, auth, region);
 
 		await sandboxRmFile(client, {

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

@@ -1,9 +1,9 @@
 import { z } from 'zod';
 import { createCommand } from '../../../types';
 import * as tui from '../../../tui';
-import { createSandboxClient, getSandboxRegion } from './util';
+import { createSandboxClient } from './util';
 import { getCommand } from '../../../command-prefix';
-import { sandboxRmDir } from '@agentuity/server';
+import { sandboxRmDir, sandboxResolve } from '@agentuity/server';
 
 const RmDirResponseSchema = z.object({
 	success: z.boolean(),
@@ -14,7 +14,7 @@ export const rmdirSubcommand = createCommand({
 	name: 'rmdir',
 	description: 'Remove a directory from a sandbox',
 	tags: ['slow', 'requires-auth'],
-	requires: { auth: true, org: true },
+	requires: { auth: true, apiClient: true },
 	examples: [
 		{
 			command: getCommand('cloud sandbox rmdir sbx_abc123 /path/to/dir'),
@@ -44,8 +44,12 @@ export const rmdirSubcommand = createCommand({
 	},
 
 	async handler(ctx) {
-		const { args, opts, options, auth, logger, orgId, config } = ctx;
-		const region = await getSandboxRegion(logger, auth, config?.name, args.sandboxId, orgId);
+		const { args, opts, options, auth, logger, apiClient } = ctx;
+
+		// Resolve sandbox to get region and orgId using CLI API
+		const sandboxInfo = await sandboxResolve(apiClient, args.sandboxId);
+		const { region, orgId } = sandboxInfo;
+
 		const client = createSandboxClient(logger, auth, region);
 
 		await sandboxRmDir(client, {

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

@@ -128,7 +128,7 @@ export const runSubcommand = createCommand({
 			}
 		}
 
-		const files = parseFileArgs(opts.file);
+		const files = await parseFileArgs(opts.file);
 		const hasFiles = files.length > 0;
 
 		const abortController = new AbortController();

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

@@ -65,26 +65,26 @@ function buildFileTree(files: SnapshotFileInfo[]): TreeNode {
 		const parts = file.path.split('/');
 		let current = root;
 
-	for (let i = 0; i < parts.length; i++) {
-		const part = parts[i];
-		if (!part) continue;
-		if (!current.children.has(part)) {
-			current.children.set(part, {
-				name: part,
-				isFile: i === parts.length - 1,
-				children: new Map(),
-			});
-		}
-		const child = current.children.get(part);
-		if (!child) continue;
-		current = child;
+		for (let i = 0; i < parts.length; i++) {
+			const part = parts[i];
+			if (!part) continue;
+			if (!current.children.has(part)) {
+				current.children.set(part, {
+					name: part,
+					isFile: i === parts.length - 1,
+					children: new Map(),
+				});
+			}
+			const child = current.children.get(part);
+			if (!child) continue;
+			current = child;
 
-		if (i === parts.length - 1) {
-			current.size = file.size;
-			current.isFile = true;
+			if (i === parts.length - 1) {
+				current.size = file.size;
+				current.isFile = true;
+			}
 		}
 	}
-	}
 
 	return root;
 }
@@ -647,15 +647,15 @@ export const buildSubcommand = createCommand({
 					}
 				}
 
-			if (finalEnv && Object.keys(finalEnv).length > 0) {
-				console.log('');
-				tui.info('Environment:');
-				for (const [envKey, envValue] of Object.entries(finalEnv)) {
-					console.log(`  ${tui.muted('•')} ${envKey}=${tui.maskSecret(envValue)}`);
+				if (finalEnv && Object.keys(finalEnv).length > 0) {
+					console.log('');
+					tui.info('Environment:');
+					for (const [envKey, envValue] of Object.entries(finalEnv)) {
+						console.log(`  ${tui.muted('•')} ${envKey}=${tui.maskSecret(envValue)}`);
+					}
 				}
-			}
 
-			if (fileList.length > 0) {
+				if (fileList.length > 0) {
 					console.log('');
 					tui.info('Files:');
 					printFileTree(fileList);
@@ -949,15 +949,15 @@ export const buildSubcommand = createCommand({
 					}
 				}
 
-			if (finalEnv && Object.keys(finalEnv).length > 0) {
-				console.log('');
-				tui.info('Environment:');
-				for (const [envKey, envValue] of Object.entries(finalEnv)) {
-					console.log(`  ${tui.muted('•')} ${envKey}=${tui.maskSecret(envValue)}`);
+				if (finalEnv && Object.keys(finalEnv).length > 0) {
+					console.log('');
+					tui.info('Environment:');
+					for (const [envKey, envValue] of Object.entries(finalEnv)) {
+						console.log(`  ${tui.muted('•')} ${envKey}=${tui.maskSecret(envValue)}`);
+					}
 				}
-			}
 
-			if (finalMetadata && Object.keys(finalMetadata).length > 0) {
+				if (finalMetadata && Object.keys(finalMetadata).length > 0) {
 					console.log('');
 					tui.info('Metadata:');
 					for (const key of Object.keys(finalMetadata)) {