@agentuity/cli 0.0.42 → 0.0.43

package/src/cmd/auth/whoami.ts

@@ -0,0 +1,69 @@
+import { z } from 'zod';
+import { createSubcommand } from '../../types';
+import * as tui from '../../tui';
+import { whoami } from '@agentuity/server';
+import { getAPIBaseURL, APIClient } from '../../api';
+
+export const whoamiCommand = createSubcommand({
+	name: 'whoami',
+	description: 'Display information about the currently authenticated user',
+	requiresAuth: true,
+	schema: {
+		options: z.object({
+			format: z
+				.enum(['json', 'table'])
+				.optional()
+				.describe('the output format: json, table (default)'),
+		}),
+	},
+
+	async handler(ctx) {
+		const { config, opts, auth } = ctx;
+
+		const apiUrl = getAPIBaseURL(config);
+		const client = new APIClient(apiUrl, config);
+
+		const result = await tui.spinner('Fetching user information', () => {
+			return whoami(client!);
+		});
+
+		if (!result.data) {
+			tui.fatal('Failed to get user information');
+		}
+
+		const user = result.data;
+
+		if (opts?.format === 'json') {
+			console.log(
+				JSON.stringify(
+					{
+						userId: auth?.userId,
+						firstName: user.firstName,
+						lastName: user.lastName,
+						organizations: user.organizations,
+					},
+					null,
+					2
+				)
+			);
+		} else {
+			const fullName = `${user.firstName} ${user.lastName}`;
+
+			tui.newline();
+			console.log(tui.bold('Currently logged in as:'));
+			tui.newline();
+			console.log(`  ${tui.padRight('Name:', 15, ' ')} ${tui.bold(fullName)}`);
+			console.log(`  ${tui.padRight('User ID:', 15, ' ')} ${tui.muted(auth?.userId || '')}`);
+			tui.newline();
+
+			if (user.organizations.length > 0) {
+				console.log(tui.bold('Organizations:'));
+				tui.newline();
+				for (const org of user.organizations) {
+					console.log(`  ${tui.padRight(org.name, 30, ' ')} ${tui.muted(org.id)}`);
+				}
+			}
+			tui.newline();
+		}
+	},
+});

package/src/cmd/bundle/index.ts

@@ -1,9 +1,9 @@
-import { createSubcommand } from '../../types';
+import { createCommand } from '../../types';
 import { z } from 'zod';
 import { resolve } from 'node:path';
 import { bundle } from './bundler';
 
-export const command = createSubcommand({
+export const command = createCommand({
 	name: 'bundle',
 	description: 'Bundle Agentuity application for deployment',
 	aliases: ['build'],

package/src/cmd/cloud/deploy.ts

@@ -0,0 +1,129 @@
+import { createSubcommand } from '../../types';
+import { z } from 'zod';
+import { join } from 'node:path';
+import * as tui from '../../tui';
+import { loadProjectConfig, saveProjectDir } from '../../config';
+import { runSteps, stepSuccess, stepSkipped, stepError } from '../../steps';
+import { bundle } from '../bundle/bundler';
+import { loadBuildMetadata } from '../../config';
+import { projectEnvUpdate } from '@agentuity/server';
+import { getAPIBaseURL, APIClient } from '../../api';
+import {
+	findEnvFile,
+	readEnvFile,
+	filterAgentuitySdkKeys,
+	splitEnvAndSecrets,
+} from '../../env-util';
+
+export const deploySubcommand = createSubcommand({
+	name: 'deploy',
+	description: 'Deploy project to the Agentuity Cloud',
+	toplevel: true,
+	requiresAuth: true,
+	schema: {
+		options: z.object({
+			dir: z.string().optional().describe('Directory to use for the project'),
+		}),
+	},
+
+	async handler(ctx) {
+		const { opts, config } = ctx;
+		const dir = opts?.dir ?? process.cwd();
+		try {
+			const project = await loadProjectConfig(dir);
+			if (!project) {
+				console.log(project); // FIXME
+			}
+			await saveProjectDir(dir);
+
+			const apiUrl = getAPIBaseURL(config);
+			const client = new APIClient(apiUrl, config);
+
+			await runSteps([
+				{
+					label: 'Sync Environment Variables',
+					run: async () => {
+						try {
+							// Read local env file (.env.production or .env)
+							const envFilePath = await findEnvFile(dir);
+							const localEnv = await readEnvFile(envFilePath);
+
+							// Filter out AGENTUITY_ keys
+							const filteredEnv = filterAgentuitySdkKeys(localEnv);
+
+							if (Object.keys(filteredEnv).length === 0) {
+								return stepSkipped('no environment variables to sync');
+							}
+
+							// Split into env and secrets
+							const { env, secrets } = splitEnvAndSecrets(filteredEnv);
+
+							// Push to cloud
+							await projectEnvUpdate(client, {
+								id: project.projectId,
+								env,
+								secrets,
+							});
+
+							return stepSuccess();
+						} catch (ex) {
+							// Non-fatal: log warning but continue deployment
+							const _ex = ex as Error;
+							return stepSkipped(_ex.message ?? 'failed to sync env variables');
+						}
+					},
+				},
+				{
+					label: 'Create Deployment',
+					run: async () => {
+						// TODO: implement
+						await Bun.sleep(1500);
+						return stepSuccess();
+					},
+				},
+				{
+					label: 'Build, Verify and Package',
+					run: async () => {
+						try {
+							await bundle({
+								rootDir: dir,
+								dev: false,
+							});
+							await loadBuildMetadata(join(dir, '.agentuity'));
+							return stepSuccess();
+						} catch (ex) {
+							const _ex = ex as Error;
+							return stepError(_ex.message ?? 'Error building your project');
+						}
+					},
+				},
+				{
+					label: 'Encrypt and Upload Deployment',
+					run: async () => {
+						// TODO: implement
+						await Bun.sleep(800);
+						return stepSkipped('already up to date');
+					},
+				},
+				{
+					label: 'Provision Services',
+					run: async () => {
+						// TODO: implement
+						await Bun.sleep(1200);
+						return stepSuccess();
+					},
+				},
+			]);
+			tui.success('Your project was deployed!');
+			tui.arrow(tui.link('https://project-123455666332.agentuity.run'));
+		} catch (ex) {
+			const _ex = ex as Error;
+			if (_ex.name === 'ProjectConfigNotFoundExpection') {
+				tui.fatal(
+					`The directory ${dir} does not contain a valid Agentuity project. Missing agentuity.json`
+				);
+			}
+			tui.fatal(`unxpected error trying to deploy project. ${ex}`);
+		}
+	},
+});

package/src/cmd/cloud/index.ts

@@ -0,0 +1,8 @@
+import { createCommand } from '../../types';
+import { deploySubcommand } from './deploy';
+
+export const command = createCommand({
+	name: 'cloud',
+	description: 'Cloud related commands',
+	subcommands: [deploySubcommand],
+});

package/src/cmd/dev/index.ts

@@ -3,7 +3,7 @@ import { z } from 'zod';
 import { resolve, join } from 'node:path';
 import { bundle } from '../bundle/bundler';
 import { existsSync, FSWatcher, watch } from 'node:fs';
-import { loadBuildMetadata } from '../../config';
+import { loadBuildMetadata, saveProjectDir } from '../../config';
 import type { BuildMetadata } from '../../types';
 import * as tui from '../../tui';
 
@@ -18,7 +18,7 @@ export const command = createCommand({
 	optionalAuth: 'Continue without an account (local only)',
 
 	async handler(ctx) {
-		const { opts, logger } = ctx;
+		const { opts, logger, options } = ctx;
 
 		const rootDir = resolve(opts.dir || process.cwd());
 		const appTs = join(rootDir, 'app.ts');
@@ -40,6 +40,8 @@ export const command = createCommand({
 			process.exit(1);
 		}
 
+		await saveProjectDir(rootDir);
+
 		const devmodebody =
 			tui.muted('Local: ') +
 			tui.link('http://127.0.0.1:3000') +
@@ -231,7 +233,7 @@ export const command = createCommand({
 
 				metadata = await loadBuildMetadata(agentuityDir);
 
-				env.AGENTUITY_LOG_LEVEL = logger.level;
+				env.AGENTUITY_LOG_LEVEL = options.logLevel;
 
 				logger.trace('Starting dev server: %s', appPath);
 				// Use shell to run in a process group for proper cleanup

package/src/cmd/env/delete.ts

@@ -0,0 +1,62 @@
+import { z } from 'zod';
+import { createSubcommand } from '../../types';
+import * as tui from '../../tui';
+import { projectEnvDelete } from '@agentuity/server';
+import { getAPIBaseURL, APIClient } from '../../api';
+import { loadProjectConfig } from '../../config';
+import {
+	findExistingEnvFile,
+	readEnvFile,
+	writeEnvFile,
+	filterAgentuitySdkKeys,
+} from '../../env-util';
+
+export const deleteSubcommand = createSubcommand({
+	name: 'delete',
+	aliases: ['del', 'remove', 'rm'],
+	description: 'Delete an environment variable',
+	requiresAuth: true,
+	schema: {
+		args: z.object({
+			key: z.string().describe('the environment variable key to delete'),
+		}),
+		options: z.object({
+			dir: z.string().optional().describe('project directory (default: current directory)'),
+		}),
+	},
+
+	async handler(ctx) {
+		const { args, opts, config } = ctx;
+		const dir = opts?.dir ?? process.cwd();
+
+		// Load project config to get project ID
+		const projectConfig = await loadProjectConfig(dir);
+		if (!projectConfig) {
+			tui.fatal(`No Agentuity project found in ${dir}. Missing agentuity.json`);
+		}
+
+		const apiUrl = getAPIBaseURL(config);
+		const client = new APIClient(apiUrl, config);
+
+		// Delete from cloud
+		await tui.spinner('Deleting environment variable from cloud', () => {
+			return projectEnvDelete(client, {
+				id: projectConfig.projectId,
+				env: [args.key],
+			});
+		});
+
+		// Update local .env file (prefer .env.production, fallback to .env)
+		const envFilePath = await findExistingEnvFile(dir);
+		const currentEnv = await readEnvFile(envFilePath);
+		delete currentEnv[args.key];
+
+		// Filter out AGENTUITY_ keys before writing
+		const filteredEnv = filterAgentuitySdkKeys(currentEnv);
+		await writeEnvFile(envFilePath, filteredEnv);
+
+		tui.success(
+			`Environment variable '${args.key}' deleted successfully (cloud + ${envFilePath})`
+		);
+	},
+});

package/src/cmd/env/get.ts

@@ -0,0 +1,66 @@
+import { z } from 'zod';
+import { createSubcommand } from '../../types';
+import * as tui from '../../tui';
+import { projectGet } from '@agentuity/server';
+import { getAPIBaseURL, APIClient } from '../../api';
+import { loadProjectConfig } from '../../config';
+import { maskSecret } from '../../env-util';
+
+export const getSubcommand = createSubcommand({
+	name: 'get',
+	description: 'Get an environment variable value',
+	requiresAuth: true,
+	schema: {
+		args: z.object({
+			key: z.string().describe('the environment variable key'),
+		}),
+		options: z.object({
+			dir: z.string().optional().describe('project directory (default: current directory)'),
+			mask: z
+				.boolean()
+				.default(false)
+				.describe('mask the value in output (default: true in TTY, false otherwise)'),
+		}),
+	},
+
+	async handler(ctx) {
+		const { args, opts, config } = ctx;
+		const dir = opts?.dir ?? process.cwd();
+
+		// Load project config to get project ID
+		const projectConfig = await loadProjectConfig(dir);
+		if (!projectConfig) {
+			tui.fatal(`No Agentuity project found in ${dir}. Missing agentuity.json`);
+		}
+
+		const apiUrl = getAPIBaseURL(config);
+		const client = new APIClient(apiUrl, config);
+
+		// Fetch project with unmasked secrets
+		const project = await tui.spinner('Fetching environment variables', () => {
+			return projectGet(client, { id: projectConfig.projectId, mask: false });
+		});
+
+		// Look for the key in env
+		const value = project.env?.[args.key];
+
+		if (value === undefined) {
+			tui.fatal(`Environment variable '${args.key}' not found`);
+		}
+
+		// Display the value, masked if requested
+		if (process.stdout.isTTY) {
+			if (opts?.mask) {
+				tui.success(`${args.key}=${maskSecret(value)}`);
+			} else {
+				tui.success(`${args.key}=${value}`);
+			}
+		} else {
+			if (opts?.mask) {
+				console.log(`${args.key}=${maskSecret(value)}`);
+			} else {
+				console.log(`${args.key}=${value}`);
+			}
+		}
+	},
+});

package/src/cmd/env/import.ts

@@ -0,0 +1,117 @@
+import { z } from 'zod';
+import { createSubcommand } from '../../types';
+import * as tui from '../../tui';
+import { projectEnvUpdate } from '@agentuity/server';
+import { getAPIBaseURL, APIClient } from '../../api';
+import { loadProjectConfig } from '../../config';
+import {
+	findEnvFile,
+	readEnvFile,
+	writeEnvFile,
+	filterAgentuitySdkKeys,
+	mergeEnvVars,
+	splitEnvAndSecrets,
+	looksLikeSecret,
+} from '../../env-util';
+import { getCommand } from '../../command-prefix';
+
+export const importSubcommand = createSubcommand({
+	name: 'import',
+	description: 'Import environment variables from a file to cloud and local .env.production',
+	requiresAuth: true,
+	schema: {
+		args: z.object({
+			file: z.string().describe('path to the .env file to import'),
+		}),
+		options: z.object({
+			dir: z.string().optional().describe('project directory (default: current directory)'),
+		}),
+	},
+
+	async handler(ctx) {
+		const { args, opts, config } = ctx;
+		const dir = opts?.dir ?? process.cwd();
+
+		// Load project config to get project ID
+		const projectConfig = await loadProjectConfig(dir);
+		if (!projectConfig) {
+			tui.fatal(`No Agentuity project found in ${dir}. Missing agentuity.json`);
+		}
+
+		// Read the import file
+		const importedEnv = await readEnvFile(args.file);
+
+		if (Object.keys(importedEnv).length === 0) {
+			tui.warning(`No environment variables found in ${args.file}`);
+			return;
+		}
+
+		// Filter out AGENTUITY_ prefixed keys
+		const filteredEnv = filterAgentuitySdkKeys(importedEnv);
+
+		if (Object.keys(filteredEnv).length === 0) {
+			tui.warning('No valid environment variables to import (all were AGENTUITY_ prefixed)');
+			return;
+		}
+
+		// Check for potential secrets in the imported variables
+		const potentialSecrets: string[] = [];
+		for (const [key, value] of Object.entries(filteredEnv)) {
+			if (looksLikeSecret(key, value)) {
+				potentialSecrets.push(key);
+			}
+		}
+
+		if (potentialSecrets.length > 0) {
+			tui.warning(
+				`Found ${potentialSecrets.length} variable(s) that look like they should be secrets:`
+			);
+			for (const key of potentialSecrets) {
+				tui.info(`  • ${key}`);
+			}
+			tui.info(`\nSecrets should be stored using: ${getCommand('secret import <file>')}`);
+			tui.info('This keeps them more secure and properly masked in the cloud.');
+
+			const response = await tui.confirm(
+				'Do you still want to import these as regular environment variables?',
+				false
+			);
+
+			if (!response) {
+				tui.info(
+					`Cancelled. Use "${getCommand('secret import')}" to store these as secrets instead.`
+				);
+				return;
+			}
+		}
+
+		const apiUrl = getAPIBaseURL(config);
+		const client = new APIClient(apiUrl, config);
+
+		// Split into env and secrets based on key naming conventions
+		const { env: normalEnv, secrets } = splitEnvAndSecrets(filteredEnv);
+
+		// Push to cloud
+		await tui.spinner('Importing environment variables to cloud', () => {
+			return projectEnvUpdate(client, {
+				id: projectConfig.projectId,
+				env: normalEnv,
+				secrets: secrets,
+			});
+		});
+
+		// Merge with local .env.production file
+		const localEnvPath = await findEnvFile(dir);
+		const localEnv = await readEnvFile(localEnvPath);
+		const mergedEnv = mergeEnvVars(localEnv, filteredEnv);
+
+		await writeEnvFile(localEnvPath, mergedEnv, {
+			skipKeys: Object.keys(mergedEnv).filter((k) => k.startsWith('AGENTUITY_')),
+		});
+
+		const count = Object.keys(filteredEnv).length;
+		tui.success(
+			`Imported ${count} environment variable${count !== 1 ? 's' : ''} from ${args.file} to cloud and ${localEnvPath}`
+		);
+	},
+});

package/src/cmd/env/index.ts

@@ -0,0 +1,22 @@
+import { createCommand } from '../../types';
+import { pullSubcommand } from './pull';
+import { pushSubcommand } from './push';
+import { setSubcommand } from './set';
+import { getSubcommand } from './get';
+import { deleteSubcommand } from './delete';
+import { importSubcommand } from './import';
+import { listSubcommand } from './list';
+
+export const command = createCommand({
+	name: 'env',
+	description: 'Manage environment variables for your project',
+	subcommands: [
+		listSubcommand,
+		pullSubcommand,
+		pushSubcommand,
+		setSubcommand,
+		getSubcommand,
+		deleteSubcommand,
+		importSubcommand,
+	],
+});

package/src/cmd/env/list.ts

@@ -0,0 +1,69 @@
+import { z } from 'zod';
+import { createSubcommand } from '../../types';
+import * as tui from '../../tui';
+import { projectGet } from '@agentuity/server';
+import { getAPIBaseURL, APIClient } from '../../api';
+import { loadProjectConfig } from '../../config';
+import { maskSecret } from '../../env-util';
+
+export const listSubcommand = createSubcommand({
+	name: 'list',
+	aliases: ['ls'],
+	description: 'List all environment variables',
+	requiresAuth: true,
+	schema: {
+		options: z.object({
+			dir: z.string().optional().describe('project directory (default: current directory)'),
+			mask: z
+				.boolean()
+				.default(false)
+				.describe('mask the values in output (default: false for env vars)'),
+		}),
+	},
+
+	async handler(ctx) {
+		const { opts, config } = ctx;
+		const dir = opts?.dir ?? process.cwd();
+
+		// Load project config to get project ID
+		const projectConfig = await loadProjectConfig(dir);
+		if (!projectConfig) {
+			tui.fatal(`No Agentuity project found in ${dir}. Missing agentuity.json`);
+		}
+
+		const apiUrl = getAPIBaseURL(config);
+		const client = new APIClient(apiUrl, config);
+
+		// Fetch project with unmasked secrets
+		const project = await tui.spinner('Fetching environment variables', () => {
+			return projectGet(client, { id: projectConfig.projectId, mask: false });
+		});
+
+		const env = project.env || {};
+
+		if (Object.keys(env).length === 0) {
+			tui.info('No environment variables found');
+			return;
+		}
+
+		// Display the variables
+		if (process.stdout.isTTY) {
+			tui.newline();
+			tui.info(`Environment Variables (${Object.keys(env).length}):`);
+			tui.newline();
+		}
+
+		const sortedKeys = Object.keys(env).sort();
+		// For env vars, masking should be explicitly opted-in (default false)
+		const shouldMask = opts?.mask === true;
+		for (const key of sortedKeys) {
+			const value = env[key];
+			const displayValue = shouldMask ? maskSecret(value) : value;
+			if (process.stdout.isTTY) {
+				console.log(`${tui.bold(key)}=${displayValue}`);
+			} else {
+				console.log(`${key}=${displayValue}`);
+			}
+		}
+	},
+});

package/src/cmd/env/pull.ts

@@ -0,0 +1,93 @@
+import { z } from 'zod';
+import { join } from 'node:path';
+import { createSubcommand } from '../../types';
+import * as tui from '../../tui';
+import { projectGet } from '@agentuity/server';
+import { getAPIBaseURL, APIClient } from '../../api';
+import { loadProjectConfig } from '../../config';
+import {
+	findEnvFile,
+	findExistingEnvFile,
+	readEnvFile,
+	writeEnvFile,
+	mergeEnvVars,
+} from '../../env-util';
+
+export const pullSubcommand = createSubcommand({
+	name: 'pull',
+	description: 'Pull environment variables from cloud to local .env.production file',
+	requiresAuth: true,
+	schema: {
+		options: z.object({
+			dir: z.string().optional().describe('project directory (default: current directory)'),
+			force: z.boolean().default(false).describe('overwrite local values with cloud values'),
+		}),
+	},
+
+	async handler(ctx) {
+		const { opts, config } = ctx;
+		const dir = opts?.dir ?? process.cwd();
+
+		// Load project config to get project ID
+		const projectConfig = await loadProjectConfig(dir);
+		if (!projectConfig) {
+			tui.fatal(`No Agentuity project found in ${dir}. Missing agentuity.json`);
+		}
+
+		const apiUrl = getAPIBaseURL(config);
+		const client = new APIClient(apiUrl, config);
+
+		// Fetch project with unmasked secrets
+		const project = await tui.spinner('Pulling environment variables from cloud', () => {
+			return projectGet(client, { id: projectConfig.projectId, mask: false });
+		});
+
+		const cloudEnv = project.env || {};
+
+		// Read current local env from existing file (.env.production or .env)
+		const existingEnvPath = await findExistingEnvFile(dir);
+		const localEnv = await readEnvFile(existingEnvPath);
+
+		// Target file is always .env.production
+		const targetEnvPath = await findEnvFile(dir);
+
+		// Merge: cloud values override local if force=true, otherwise keep local
+		let mergedEnv: Record<string, string>;
+		if (opts?.force) {
+			// Cloud values take priority
+			mergedEnv = mergeEnvVars(localEnv, cloudEnv);
+		} else {
+			// Local values take priority (only add new keys from cloud)
+			mergedEnv = mergeEnvVars(cloudEnv, localEnv);
+		}
+
+		// Write to .env.production (skip AGENTUITY_ keys)
+		await writeEnvFile(targetEnvPath, mergedEnv, {
+			skipKeys: Object.keys(mergedEnv).filter((k) => k.startsWith('AGENTUITY_')),
+		});
+
+		// Write AGENTUITY_SDK_KEY to .env if present and missing locally
+		if (project.api_key) {
+			const dotEnvPath = join(dir, '.env');
+			const dotEnv = await readEnvFile(dotEnvPath);
+
+			if (!dotEnv.AGENTUITY_SDK_KEY) {
+				dotEnv.AGENTUITY_SDK_KEY = project.api_key;
+				await writeEnvFile(dotEnvPath, dotEnv, {
+					addComment: (key) => {
+						if (key === 'AGENTUITY_SDK_KEY') {
+							return 'AGENTUITY_SDK_KEY is a sensitive value and should not be committed to version control.';
+						}
+						return null;
+					},
+				});
+				tui.info(`Wrote AGENTUITY_SDK_KEY to ${dotEnvPath}`);
+			}
+		}
+
+		const count = Object.keys(cloudEnv).length;
+		tui.success(
+			`Pulled ${count} environment variable${count !== 1 ? 's' : ''} to ${targetEnvPath}`
+		);
+	},
+});