@agentuity/cli 0.0.41 → 0.0.43

package/src/cmd/env/set.ts

@@ -0,0 +1,86 @@
+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,
+	looksLikeSecret,
+} from '../../env-util';
+import { getCommand } from '../../command-prefix';
+
+export const setSubcommand = createSubcommand({
+	name: 'set',
+	description: 'Set an environment variable',
+	requiresAuth: true,
+	schema: {
+		args: z.object({
+			key: z.string().describe('the environment variable key'),
+			value: z.string().describe('the environment variable value'),
+		}),
+		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();
+
+		// Validate key doesn't start with AGENTUITY_
+		if (args.key.startsWith('AGENTUITY_')) {
+			tui.fatal('Cannot set AGENTUITY_ prefixed variables. These are reserved for system use.');
+		}
+
+		// Detect if this looks like a secret
+		if (looksLikeSecret(args.key, args.value)) {
+			tui.warning(`The variable '${args.key}' looks like it should be a secret.`);
+			tui.info(`Secrets should be stored using: ${getCommand('secret set <key> <value>')}`);
+			tui.info('This keeps them more secure and properly masked in the cloud.');
+
+			const response = await tui.confirm(
+				'Do you still want to store this as a regular environment variable?',
+				false
+			);
+
+			if (!response) {
+				tui.info(
+					`Cancelled. Use "${getCommand('secret set')}" to store this as a secret instead.`
+				);
+				return;
+			}
+		}
+
+		// 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);
+
+		// Set in cloud
+		await tui.spinner('Setting environment variable in cloud', () => {
+			return projectEnvUpdate(client, {
+				id: projectConfig.projectId,
+				env: { [args.key]: args.value },
+			});
+		});
+
+		// Update local .env.production file
+		const envFilePath = await findEnvFile(dir);
+		const currentEnv = await readEnvFile(envFilePath);
+		currentEnv[args.key] = args.value;
+
+		// Filter out AGENTUITY_ keys before writing
+		const filteredEnv = filterAgentuitySdkKeys(currentEnv);
+		await writeEnvFile(envFilePath, filteredEnv);
+
+		tui.success(`Environment variable '${args.key}' set successfully (cloud + ${envFilePath})`);
+	},
+});

package/src/cmd/project/create.ts

@@ -31,7 +31,7 @@ export const createProjectSubcommand = createSubcommand({
 				.optional()
 				.default(true)
 				.describe('Run bun run build after installing (use --no-build to skip)'),
-			confirm: z.boolean().optional().describe('Show confirmation prompts'),
+			confirm: z.boolean().optional().describe('Skip confirmation prompts'),
 			register: z
 				.boolean()
 				.default(true)

package/src/cmd/project/delete.ts

@@ -1,13 +1,54 @@
+import { z } from 'zod';
 import { createSubcommand } from '../../types';
+import * as tui from '../../tui';
+import { projectDelete } from '@agentuity/server';
+import { getAPIBaseURL, APIClient } from '../../api';
 
 export const deleteSubcommand = createSubcommand({
 	name: 'delete',
 	description: 'Delete a project',
 	aliases: ['rm', 'del'],
 	requiresAuth: true,
+	schema: {
+		args: z.object({
+			id: z.string().describe('the project id'),
+		}),
+		options: z.object({
+			confirm: z.boolean().optional().describe('Skip confirmation prompts'),
+		}),
+	},
 
 	async handler(ctx) {
-		const { logger } = ctx;
-		logger.info('TODO: Implement project delete functionality');
+		const { args, opts, config } = ctx;
+
+		const apiUrl = getAPIBaseURL(config);
+		const client = new APIClient(apiUrl, config);
+
+		const skipConfirm = opts?.confirm === true;
+
+		if (!process.stdout.isTTY && !skipConfirm) {
+			tui.fatal('no TTY and --confirm is false');
+		}
+
+		if (!skipConfirm) {
+			const ok = await tui.confirm('Are you sure you want to delete', false);
+			if (!ok) {
+				return;
+			}
+		}
+
+		const deleted = await tui.spinner('Deleting project', async () => {
+			const val = await projectDelete(client!, args.id);
+			if (val.length === 1 && val[0] === args.id) {
+				return true;
+			}
+			return false;
+		});
+
+		if (deleted) {
+			tui.success(`Project ${args.id} deleted`);
+		} else {
+			tui.warning(`${args.id} not found`);
+		}
 	},
 });

package/src/cmd/project/download.ts

@@ -13,7 +13,7 @@ import { tmpdir } from 'node:os';
 import { finished } from 'node:stream/promises';
 import { createGunzip } from 'node:zlib';
 import { extract, type Headers } from 'tar-fs';
-import type { Logger } from '../../logger';
+import type { Logger } from '@agentuity/core';
 import * as tui from '../../tui';
 import { downloadWithSpinner } from '../../download';
 import type { TemplateInfo } from './templates';

package/src/cmd/project/list.ts

@@ -1,13 +1,44 @@
+import { z } from 'zod';
 import { createSubcommand } from '../../types';
+import * as tui from '../../tui';
+import { projectList } from '@agentuity/server';
+import { getAPIBaseURL, APIClient } from '../../api';
 
 export const listSubcommand = createSubcommand({
 	name: 'list',
 	description: 'List all projects',
 	aliases: ['ls'],
 	requiresAuth: true,
+	schema: {
+		options: z.object({
+			format: z
+				.enum(['json', 'table'])
+				.optional()
+				.describe('the output format: json, table (default)'),
+		}),
+	},
 
 	async handler(ctx) {
-		const { logger } = ctx;
-		logger.info('TODO: Implement project list functionality');
+		const { config, opts } = ctx;
+
+		const apiUrl = getAPIBaseURL(config);
+		const client = new APIClient(apiUrl, config);
+
+		const projects = await tui.spinner('Fetching projects', () => {
+			return projectList(client!);
+		});
+
+		// TODO: might want to sort by the last org_id we used
+		if (projects) {
+			projects.sort((a, b) => {
+				return a.name.localeCompare(b.name);
+			});
+		}
+
+		if (opts?.format === 'json') {
+			console.log(JSON.stringify(projects, null, 2));
+		} else {
+			console.table(projects, ['id', 'name', 'orgName']);
+		}
 	},
 });

package/src/cmd/project/show.ts

@@ -1,12 +1,44 @@
+import { z } from 'zod';
 import { createSubcommand } from '../../types';
+import * as tui from '../../tui';
+import { projectGet } from '@agentuity/server';
+import { getAPIBaseURL, APIClient } from '../../api';
 
 export const showSubcommand = createSubcommand({
 	name: 'show',
-	description: 'Show project details',
+	aliases: ['get'],
+	description: 'Show project detail',
 	requiresAuth: true,
+	schema: {
+		args: z.object({
+			id: z.string().describe('the project id'),
+		}),
+		options: z.object({
+			format: z
+				.enum(['json', 'table'])
+				.optional()
+				.describe('the output format: json, table (default)'),
+		}),
+	},
 
 	async handler(ctx) {
-		const { logger } = ctx;
-		logger.info('TODO: Implement project show functionality');
+		const { opts, args, config } = ctx;
+
+		const apiUrl = getAPIBaseURL(config);
+		const client = new APIClient(apiUrl, config);
+
+		const project = await tui.spinner('Fetching project', () => {
+			return projectGet(client!, { id: args.id, mask: true });
+		});
+
+		if (!project) {
+			tui.fatal('Project not found');
+		}
+
+		if (opts?.format === 'json') {
+			console.log(JSON.stringify(project, null, 2));
+		} else {
+			console.table([project], ['id', 'orgId']);
+		}
 	},
 });

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

@@ -4,12 +4,13 @@ import { cwd } from 'node:process';
 import { homedir } from 'node:os';
 import enquirer from 'enquirer';
 import {
-	createProject,
+	projectCreate,
 	projectExists,
 	listOrganizations,
+	projectEnvUpdate,
 	type OrganizationList,
 } from '@agentuity/server';
-import type { Logger } from '../../logger';
+import type { Logger } from '@agentuity/core';
 import * as tui from '../../tui';
 import { playSound } from '../../sound';
 import { fetchTemplates, type TemplateInfo } from './templates';
@@ -17,7 +18,13 @@ import { downloadTemplate, setupProject } from './download';
 import { showBanner } from '../../banner';
 import type { AuthData, Config } from '../../types';
 import { getAPIBaseURL, APIClient } from '../../api';
-import { createProjectConfig } from '../../config';
+import { createProjectConfig, saveOrgId } from '../../config';
+import {
+	findEnvFile,
+	readEnvFile,
+	filterAgentuitySdkKeys,
+	splitEnvAndSecrets,
+} from '../../env-util';
 
 interface CreateFlowOptions {
 	projectName?: string;
@@ -53,10 +60,8 @@ export async function runCreateFlow(options: CreateFlowOptions): Promise<void> {
 		tui.info(`📋 Loading templates from local directory: ${templateDir}...\n`);
 	}
 
-	let templates: TemplateInfo[] = [];
-
-	await tui.spinner('Fetching templates', async () => {
-		templates = await fetchTemplates(templateDir, templateBranch);
+	const templates = await tui.spinner('Fetching templates', async () => {
+		return fetchTemplates(templateDir, templateBranch);
 	});
 
 	if (templates.length === 0) {
@@ -73,13 +78,20 @@ export async function runCreateFlow(options: CreateFlowOptions): Promise<void> {
 	if (auth) {
 		const apiUrl = getAPIBaseURL(config);
 		client = new APIClient(apiUrl, config);
-		await tui.spinner('Fetching organizations', async () => {
+		orgs = await tui.spinner('Fetching organizations', async () => {
 			const resp = await listOrganizations(client!);
 			if (resp.data) {
-				orgs = resp.data;
+				return resp.data;
 			}
 		});
-		orgId = await tui.selectOrganization(orgs!, config?.preferences?.orgId);
+		if (!orgs) {
+			tui.fatal('no organizations could be found for your login');
+		}
+		orgId = await tui.selectOrganization(orgs, config?.preferences?.orgId);
+
+		if (orgId && orgId !== config?.preferences?.orgId) {
+			await saveOrgId(orgId);
+		}
 	}
 
 	if (!projectName && !skipPrompts) {
@@ -200,21 +212,50 @@ export async function runCreateFlow(options: CreateFlowOptions): Promise<void> {
 	});
 
 	if (auth && client && orgId) {
+		let projectId: string | undefined;
+
 		await tui.spinner('Registering your project', async () => {
-			const res = await createProject(client, {
+			const res = await projectCreate(client, {
 				name: projectName,
 				organization_id: orgId,
 				provider: 'bunjs',
 			});
 			if (res.success && res.data) {
+				projectId = res.data.id;
 				return createProjectConfig(dest, {
 					projectId: res.data.id,
 					orgId,
 					apiKey: res.data.api_key,
 				});
 			}
-			tui.fatal(res.message!);
+			tui.fatal(res.message ?? 'failed to register project');
 		});
+
+		// After registration, push any existing env/secrets from .env.production
+		if (projectId) {
+			await tui.spinner('Syncing environment variables', async () => {
+				try {
+					const envFilePath = await findEnvFile(dest);
+					const localEnv = await readEnvFile(envFilePath);
+					const filteredEnv = filterAgentuitySdkKeys(localEnv);
+
+					if (Object.keys(filteredEnv).length > 0) {
+						const { env, secrets } = splitEnvAndSecrets(filteredEnv);
+						await projectEnvUpdate(client, {
+							id: projectId!,
+							env,
+							secrets,
+						});
+						logger.debug(
+							`Synced ${Object.keys(filteredEnv).length} environment variables to cloud`
+						);
+					}
+				} catch (error) {
+					// Non-fatal: just log the error
+					logger.debug('Failed to sync environment variables:', error);
+				}
+			});
+		}
 	}
 
 	// Step 8: Show completion message

package/src/cmd/secret/delete.ts

@@ -0,0 +1,55 @@
+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 { findEnvFile, readEnvFile, writeEnvFile, filterAgentuitySdkKeys } from '../../env-util';
+
+export const deleteSubcommand = createSubcommand({
+	name: 'delete',
+	aliases: ['del', 'remove', 'rm'],
+	description: 'Delete a secret',
+	requiresAuth: true,
+	schema: {
+		args: z.object({
+			key: z.string().describe('the secret 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 (using secrets field)
+		await tui.spinner('Deleting secret from cloud', () => {
+			return projectEnvDelete(client, {
+				id: projectConfig.projectId,
+				secrets: [args.key],
+			});
+		});
+
+		// Update local .env.production file
+		const envFilePath = await findEnvFile(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(`Secret '${args.key}' deleted successfully (cloud + ${envFilePath})`);
+	},
+});

package/src/cmd/secret/get.ts

@@ -0,0 +1,67 @@
+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 a secret value',
+	requiresAuth: true,
+	schema: {
+		args: z.object({
+			key: z.string().describe('the secret key'),
+		}),
+		options: z.object({
+			dir: z.string().optional().describe('project directory (default: current directory)'),
+			mask: z
+				.boolean()
+				.default(!!process.stdout.isTTY)
+				.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 secrets', () => {
+			return projectGet(client, { id: projectConfig.projectId, mask: false });
+		});
+
+		// Look for the key in secrets
+		const value = project.secrets?.[args.key];
+
+		if (value === undefined) {
+			tui.fatal(`Secret '${args.key}' not found`);
+		}
+
+		if (process.stdout.isTTY) {
+			// Display the value, masked by default
+			if (opts?.mask) {
+				tui.success(`${args.key}=${maskSecret(value)}`);
+			} else {
+				tui.success(`${args.key}=${value}`);
+			}
+		} else {
+			// Display the value, masked by default
+			if (opts?.mask) {
+				console.log(`${args.key}=${maskSecret(value)}`);
+			} else {
+				console.log(`${args.key}=${value}`);
+			}
+		}
+	},
+});

package/src/cmd/secret/import.ts

@@ -0,0 +1,79 @@
+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,
+} from '../../env-util';
+
+export const importSubcommand = createSubcommand({
+	name: 'import',
+	description: 'Import secrets 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 importedSecrets = await readEnvFile(args.file);
+
+		if (Object.keys(importedSecrets).length === 0) {
+			tui.warning(`No secrets found in ${args.file}`);
+			return;
+		}
+
+		// Filter out AGENTUITY_ prefixed keys
+		const filteredSecrets = filterAgentuitySdkKeys(importedSecrets);
+
+		if (Object.keys(filteredSecrets).length === 0) {
+			tui.warning('No valid secrets to import (all were AGENTUITY_ prefixed)');
+			return;
+		}
+
+		const apiUrl = getAPIBaseURL(config);
+		const client = new APIClient(apiUrl, config);
+
+		// Push to cloud (using secrets field)
+		await tui.spinner('Importing secrets to cloud', () => {
+			return projectEnvUpdate(client, {
+				id: projectConfig.projectId,
+				secrets: filteredSecrets,
+			});
+		});
+
+		// Merge with local .env.production file
+		const localEnvPath = await findEnvFile(dir);
+		const localEnv = await readEnvFile(localEnvPath);
+		const mergedEnv = mergeEnvVars(localEnv, filteredSecrets);
+
+		await writeEnvFile(localEnvPath, mergedEnv, {
+			skipKeys: Object.keys(mergedEnv).filter((k) => k.startsWith('AGENTUITY_')),
+		});
+
+		const count = Object.keys(filteredSecrets).length;
+		tui.success(
+			`Imported ${count} secret${count !== 1 ? 's' : ''} from ${args.file} to cloud and ${localEnvPath}`
+		);
+	},
+});

package/src/cmd/secret/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: 'secret',
+	description: 'Manage secrets for your project',
+	subcommands: [
+		listSubcommand,
+		pullSubcommand,
+		pushSubcommand,
+		setSubcommand,
+		getSubcommand,
+		deleteSubcommand,
+		importSubcommand,
+	],
+});

package/src/cmd/secret/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 secrets',
+	requiresAuth: true,
+	schema: {
+		options: z.object({
+			dir: z.string().optional().describe('project directory (default: current directory)'),
+			mask: z
+				.boolean()
+				.default(!!process.stdout.isTTY)
+				.describe('mask the values in output (default: true in TTY for secrets)'),
+		}),
+	},
+
+	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 secrets', () => {
+			return projectGet(client, { id: projectConfig.projectId, mask: false });
+		});
+
+		const secrets = project.secrets || {};
+
+		if (Object.keys(secrets).length === 0) {
+			tui.info('No secrets found');
+			return;
+		}
+
+		// Display the secrets
+		if (process.stdout.isTTY) {
+			tui.newline();
+			tui.success(`Secrets (${Object.keys(secrets).length}):`);
+			tui.newline();
+		}
+
+		const sortedKeys = Object.keys(secrets).sort();
+		// For secrets, masking is enabled by default in TTY (can be disabled with --no-mask)
+		const shouldMask = opts?.mask !== false;
+		for (const key of sortedKeys) {
+			const value = secrets[key];
+			const displayValue = shouldMask ? maskSecret(value) : value;
+			if (process.stdout.isTTY) {
+				console.log(`${tui.bold(key)}=${displayValue}`);
+			} else {
+				console.log(`${key}=${displayValue}`);
+			}
+		}
+	},
+});