@agentuity/cli 0.0.105 → 0.0.106

package/src/cmd/cloud/env/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 EnvPullResponseSchema = z.object({
@@ -21,7 +15,7 @@ const EnvPullResponseSchema = z.object({
 
 export const pullSubcommand = createSubcommand({
 	name: 'pull',
-	description: 'Pull environment variables from cloud to local .env.production file',
+	description: 'Pull environment variables 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 cloudEnv = projectData.env || {};
+		const cloudEnv = { ...projectData.env, ...projectData.secrets }; // env 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(cloudEnv, 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/env/push.ts

@@ -13,7 +13,7 @@ const EnvPushResponseSchema = z.object({
 
 export const pushSubcommand = createSubcommand({
 	name: 'push',
-	description: 'Push environment variables from local .env.production file to cloud',
+	description: 'Push environment variables from local .env file to cloud',
 	tags: [
 		'mutating',
 		'updates-resource',
@@ -33,7 +33,7 @@ export const pushSubcommand = createSubcommand({
 	async handler(ctx) {
 		const { apiClient, project, projectDir } = ctx;
 
-		// Read local env file (prefer .env.production, fallback to .env)
+		// Read local env file (prefer .env)
 		const envFilePath = await findExistingEnvFile(projectDir);
 		const localEnv = await readEnvFile(envFilePath);
 

package/src/cmd/cloud/env/set.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,
@@ -75,8 +75,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/index.ts

@@ -15,6 +15,7 @@ import secretCommand from './secret';
 import apikeyCommand from './apikey';
 import streamCommand from './stream';
 import vectorCommand from './vector';
+import sandboxCommand from './sandbox';
 import { getCommand } from '../../command-prefix';
 
 export const command = createCommand({
@@ -31,6 +32,7 @@ export const command = createCommand({
 		agentCommand,
 		streamCommand,
 		vectorCommand,
+		sandboxCommand,
 		envCommand,
 		secretCommand,
 		deploySubcommand,

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

@@ -0,0 +1,531 @@
+import { z } from 'zod';
+import { readFileSync, writeFileSync, mkdirSync, statSync, readdirSync } from 'node:fs';
+import { dirname, resolve, basename, join, relative } from 'node:path';
+import { createCommand } from '../../../types';
+import * as tui from '../../../tui';
+import { createSandboxClient } from './util';
+import { getCommand } from '../../../command-prefix';
+import {
+	sandboxWriteFiles,
+	sandboxReadFile,
+	sandboxExecute,
+	executionGet,
+	type APIClient,
+} from '@agentuity/server';
+import type { Logger, FileToWrite } from '@agentuity/core';
+
+const POLL_INTERVAL_MS = 500;
+const MAX_POLL_ATTEMPTS = 600;
+
+interface ParsedPath {
+	sandboxId: string | null;
+	path: string;
+}
+
+function parsePath(pathArg: string): ParsedPath {
+	const colonIndex = pathArg.indexOf(':');
+	if (colonIndex === -1) {
+		return { sandboxId: null, path: pathArg };
+	}
+	const prefix = pathArg.slice(0, colonIndex);
+	const path = pathArg.slice(colonIndex + 1);
+	if (prefix.startsWith('snbx_') || prefix.startsWith('sbx_')) {
+		return { sandboxId: prefix, path };
+	}
+	return { sandboxId: null, path: pathArg };
+}
+
+const SandboxCpResponseSchema = z.object({
+	source: z.string().describe('Source path'),
+	destination: z.string().describe('Destination path'),
+	bytesTransferred: z.number().describe('Number of bytes transferred'),
+	filesTransferred: z.number().describe('Number of files transferred'),
+});
+
+export const cpSubcommand = createCommand({
+	name: 'cp',
+	aliases: ['copy'],
+	description: 'Copy files or directories to or from a sandbox',
+	tags: ['slow', 'requires-auth'],
+	requires: { auth: true, region: true, org: true },
+	examples: [
+		{
+			command: getCommand('cloud sandbox cp ./local-file.txt snbx_abc123:/path/to/file.txt'),
+			description: 'Copy a local file to a sandbox',
+		},
+		{
+			command: getCommand('cloud sandbox cp snbx_abc123:/path/to/file.txt ./local-file.txt'),
+			description: 'Copy a file from a sandbox to local',
+		},
+		{
+			command: getCommand('cloud sandbox cp --recursive ./local-dir snbx_abc123:/path/to/dir'),
+			description: 'Copy a local directory to a sandbox recursively',
+		},
+		{
+			command: getCommand('cloud sandbox cp -r snbx_abc123:/path/to/dir ./local-dir'),
+			description: 'Copy a directory from a sandbox to local recursively',
+		},
+	],
+	schema: {
+		args: z.object({
+			source: z.string().describe('Source path (local path or sandboxId:/remote/path)'),
+			destination: z
+				.string()
+				.describe('Destination path (local path or sandboxId:/remote/path)'),
+		}),
+		options: z.object({
+			timeout: z.string().optional().describe('Operation timeout (e.g., "5m", "1h")'),
+			recursive: z.boolean().default(false).optional().describe('Copy directories recursively'),
+		}),
+		aliases: {
+			recursive: ['r'],
+		},
+		response: SandboxCpResponseSchema,
+	},
+
+	async handler(ctx) {
+		const { args, opts, options, auth, region, logger, orgId } = ctx;
+
+		const source = parsePath(args.source);
+		const destination = parsePath(args.destination);
+
+		if (source.sandboxId && destination.sandboxId) {
+			logger.fatal(
+				'Cannot copy between two sandboxes. Use a local path as source or destination.'
+			);
+		}
+
+		if (!source.sandboxId && !destination.sandboxId) {
+			logger.fatal(
+				'At least one path must include a sandbox ID (e.g., snbx_abc123:/path/to/file)'
+			);
+		}
+
+		const client = createSandboxClient(logger, auth, region);
+		const recursive = opts.recursive ?? false;
+
+		if (source.sandboxId) {
+			return await downloadFromSandbox(
+				client,
+				logger,
+				orgId,
+				source.sandboxId,
+				source.path,
+				destination.path,
+				opts.timeout,
+				recursive,
+				options.json ?? false
+			);
+		} else {
+			return await uploadToSandbox(
+				client,
+				logger,
+				orgId,
+				destination.sandboxId!,
+				source.path,
+				destination.path,
+				opts.timeout,
+				recursive,
+				options.json ?? false
+			);
+		}
+	},
+});
+
+function getAllFiles(dirPath: string, basePath: string = dirPath): string[] {
+	const files: string[] = [];
+	const entries = readdirSync(dirPath, { withFileTypes: true });
+
+	for (const entry of entries) {
+		const fullPath = join(dirPath, entry.name);
+		if (entry.isDirectory()) {
+			files.push(...getAllFiles(fullPath, basePath));
+		} else if (entry.isFile()) {
+			files.push(fullPath);
+		}
+	}
+
+	return files;
+}
+
+async function uploadToSandbox(
+	client: APIClient,
+	logger: Logger,
+	orgId: string,
+	sandboxId: string,
+	localPath: string,
+	remotePath: string,
+	timeout: string | undefined,
+	recursive: boolean,
+	jsonOutput: boolean
+): Promise<z.infer<typeof SandboxCpResponseSchema>> {
+	const resolvedPath = resolve(localPath);
+
+	if (!(await Bun.file(resolvedPath).exists())) {
+		const stat = statSync(resolvedPath, { throwIfNoEntry: false });
+		if (!stat) {
+			logger.fatal(`Local path not found: ${localPath}`);
+		}
+	}
+
+	const stat = statSync(resolvedPath);
+
+	if (stat.isDirectory()) {
+		if (!recursive) {
+			logger.fatal(`${localPath} is a directory. Use -r/--recursive to copy directories.`);
+		}
+		return await uploadDirectory(
+			client,
+			logger,
+			orgId,
+			sandboxId,
+			resolvedPath,
+			remotePath,
+			timeout,
+			jsonOutput
+		);
+	}
+
+	return await uploadSingleFile(
+		client,
+		logger,
+		orgId,
+		sandboxId,
+		resolvedPath,
+		localPath,
+		remotePath,
+		timeout,
+		jsonOutput
+	);
+}
+
+async function uploadSingleFile(
+	client: APIClient,
+	logger: Logger,
+	orgId: string,
+	sandboxId: string,
+	resolvedPath: string,
+	displayPath: string,
+	remotePath: string,
+	_timeout: string | undefined,
+	jsonOutput: boolean
+): Promise<z.infer<typeof SandboxCpResponseSchema>> {
+	const buffer = readFileSync(resolvedPath);
+
+	let targetPath = remotePath;
+	if (!remotePath || remotePath === '' || remotePath.endsWith('/')) {
+		const baseDir = remotePath || '';
+		targetPath = baseDir ? baseDir + basename(resolvedPath) : basename(resolvedPath);
+	}
+
+	const files: FileToWrite[] = [{ path: targetPath, content: buffer }];
+
+	await sandboxWriteFiles(client, { sandboxId, files, orgId });
+
+	if (!jsonOutput) {
+		tui.success(`Copied ${displayPath} → ${sandboxId}:${targetPath} (${buffer.length} bytes)`);
+	}
+
+	return {
+		source: displayPath,
+		destination: `${sandboxId}:${targetPath}`,
+		bytesTransferred: buffer.length,
+		filesTransferred: 1,
+	};
+}
+
+async function uploadDirectory(
+	client: APIClient,
+	logger: Logger,
+	orgId: string,
+	sandboxId: string,
+	localDir: string,
+	remotePath: string,
+	_timeout: string | undefined,
+	jsonOutput: boolean
+): Promise<z.infer<typeof SandboxCpResponseSchema>> {
+	const allFiles = getAllFiles(localDir);
+
+	if (allFiles.length === 0) {
+		logger.fatal(`Directory is empty: ${localDir}`);
+	}
+
+	const files: FileToWrite[] = [];
+	let totalBytes = 0;
+	const effectiveRemotePath = remotePath || basename(localDir);
+	const baseRemotePath = effectiveRemotePath.endsWith('/')
+		? effectiveRemotePath.slice(0, -1)
+		: effectiveRemotePath;
+
+	for (const filePath of allFiles) {
+		const relativePath = relative(localDir, filePath);
+		const targetPath = `${baseRemotePath}/${relativePath}`;
+		const buffer = readFileSync(filePath);
+		files.push({ path: targetPath, content: buffer });
+		totalBytes += buffer.length;
+	}
+
+	await sandboxWriteFiles(client, { sandboxId, files, orgId });
+
+	if (!jsonOutput) {
+		tui.success(
+			`Copied ${localDir} → ${sandboxId}:${baseRemotePath} (${allFiles.length} files, ${totalBytes} bytes)`
+		);
+	}
+
+	return {
+		source: localDir,
+		destination: `${sandboxId}:${baseRemotePath}`,
+		bytesTransferred: totalBytes,
+		filesTransferred: allFiles.length,
+	};
+}
+
+async function downloadFromSandbox(
+	client: APIClient,
+	logger: Logger,
+	orgId: string,
+	sandboxId: string,
+	remotePath: string,
+	localPath: string,
+	timeout: string | undefined,
+	recursive: boolean,
+	jsonOutput: boolean
+): Promise<z.infer<typeof SandboxCpResponseSchema>> {
+	if (recursive) {
+		return await downloadDirectory(
+			client,
+			logger,
+			orgId,
+			sandboxId,
+			remotePath,
+			localPath,
+			timeout,
+			jsonOutput
+		);
+	}
+
+	return await downloadSingleFile(
+		client,
+		logger,
+		orgId,
+		sandboxId,
+		remotePath,
+		localPath,
+		timeout,
+		jsonOutput
+	);
+}
+
+async function downloadSingleFile(
+	client: APIClient,
+	logger: Logger,
+	orgId: string,
+	sandboxId: string,
+	remotePath: string,
+	localPath: string,
+	_timeout: string | undefined,
+	jsonOutput: boolean
+): Promise<z.infer<typeof SandboxCpResponseSchema>> {
+	const stream = await sandboxReadFile(client, { sandboxId, path: remotePath, orgId });
+
+	const chunks: Uint8Array[] = [];
+	const reader = stream.getReader();
+	while (true) {
+		const { done, value } = await reader.read();
+		if (done) break;
+		if (value) chunks.push(value);
+	}
+	const buffer = Buffer.concat(chunks);
+
+	let targetPath = localPath;
+	if (localPath.endsWith('/') || localPath === '.') {
+		targetPath = resolve(localPath, basename(remotePath));
+	} else {
+		targetPath = resolve(localPath);
+	}
+
+	const dir = dirname(targetPath);
+	mkdirSync(dir, { recursive: true });
+
+	writeFileSync(targetPath, buffer);
+
+	if (!jsonOutput) {
+		tui.success(`Copied ${sandboxId}:${remotePath} → ${targetPath} (${buffer.length} bytes)`);
+	}
+
+	return {
+		source: `${sandboxId}:${remotePath}`,
+		destination: targetPath,
+		bytesTransferred: buffer.length,
+		filesTransferred: 1,
+	};
+}
+
+async function downloadDirectory(
+	client: APIClient,
+	logger: Logger,
+	orgId: string,
+	sandboxId: string,
+	remotePath: string,
+	localPath: string,
+	timeout: string | undefined,
+	jsonOutput: boolean
+): Promise<z.infer<typeof SandboxCpResponseSchema>> {
+	const listExecution = await sandboxExecute(client, {
+		sandboxId,
+		options: {
+			command: ['find', remotePath, '-type', 'f'],
+			timeout,
+		},
+		orgId,
+	});
+
+	const listChunks: Buffer[] = [];
+	if (listExecution.stdoutStreamUrl) {
+		await streamToBuffer(listExecution.stdoutStreamUrl, listChunks, logger);
+	}
+
+	await waitForExecution(client, orgId, listExecution.executionId, logger);
+
+	const fileList = Buffer.concat(listChunks)
+		.toString('utf-8')
+		.trim()
+		.split('\n')
+		.filter((f) => f.length > 0);
+
+	if (fileList.length === 0) {
+		logger.fatal(`No files found in directory: ${remotePath}`);
+	}
+
+	const baseRemotePath = remotePath.endsWith('/') ? remotePath.slice(0, -1) : remotePath;
+	const baseLocalPath = resolve(localPath);
+	let totalBytes = 0;
+
+	for (const remoteFile of fileList) {
+		const relativePath = remoteFile.startsWith(baseRemotePath + '/')
+			? remoteFile.slice(baseRemotePath.length + 1)
+			: basename(remoteFile);
+
+		const localFilePath = join(baseLocalPath, relativePath);
+
+		try {
+			const stream = await sandboxReadFile(client, { sandboxId, path: remoteFile, orgId });
+			const chunks: Uint8Array[] = [];
+			const reader = stream.getReader();
+			while (true) {
+				const { done, value } = await reader.read();
+				if (done) break;
+				if (value) chunks.push(value);
+			}
+			const buffer = Buffer.concat(chunks);
+			totalBytes += buffer.length;
+
+			const dir = dirname(localFilePath);
+			mkdirSync(dir, { recursive: true });
+			writeFileSync(localFilePath, buffer);
+
+			if (!jsonOutput) {
+				logger.info(`Downloaded ${remoteFile} (${buffer.length} bytes)`);
+			}
+		} catch (err) {
+			logger.warn(`Failed to read file: ${remoteFile}, skipping: ${err}`);
+			continue;
+		}
+	}
+
+	if (!jsonOutput) {
+		tui.success(
+			`Copied ${sandboxId}:${baseRemotePath} → ${baseLocalPath} (${fileList.length} files, ${totalBytes} bytes)`
+		);
+	}
+
+	return {
+		source: `${sandboxId}:${baseRemotePath}`,
+		destination: baseLocalPath,
+		bytesTransferred: totalBytes,
+		filesTransferred: fileList.length,
+	};
+}
+
+async function waitForExecution(
+	client: APIClient,
+	orgId: string,
+	executionId: string,
+	logger: Logger
+): Promise<void> {
+	let attempts = 0;
+
+	while (attempts < MAX_POLL_ATTEMPTS) {
+		await sleep(POLL_INTERVAL_MS);
+		attempts++;
+
+		try {
+			const execInfo = await executionGet(client, { executionId, orgId });
+
+			if (
+				execInfo.status === 'completed' ||
+				execInfo.status === 'failed' ||
+				execInfo.status === 'timeout' ||
+				execInfo.status === 'cancelled'
+			) {
+				if (execInfo.status === 'failed' || execInfo.status === 'timeout') {
+					logger.fatal(`Execution ${execInfo.status}: ${executionId}`);
+				}
+				return;
+			}
+		} catch (err) {
+			if (err instanceof Error && err.name === 'AbortError') {
+				throw err;
+			}
+			logger.debug('poll error: %s', err);
+			continue;
+		}
+	}
+
+	logger.fatal('Execution timed out waiting for completion');
+}
+
+async function streamToBuffer(url: string, chunks: Buffer[], logger: Logger): Promise<void> {
+	const maxRetries = 10;
+	const retryDelay = 200;
+
+	for (let attempt = 0; attempt < maxRetries; attempt++) {
+		try {
+			if (attempt > 0) {
+				logger.debug('stream retry attempt %d', attempt + 1);
+				await sleep(retryDelay);
+			}
+
+			const response = await fetch(url);
+
+			if (!response.ok || !response.body) {
+				continue;
+			}
+
+			const reader = response.body.getReader();
+
+			while (true) {
+				const { done, value } = await reader.read();
+				if (done) {
+					return;
+				}
+
+				if (value) {
+					chunks.push(Buffer.from(value));
+				}
+			}
+		} catch (err) {
+			if (err instanceof Error && err.name === 'AbortError') {
+				throw err;
+			}
+			logger.debug('stream error: %s', err);
+		}
+	}
+}
+
+function sleep(ms: number): Promise<void> {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+export default cpSubcommand;