@agentuity/cli 0.0.42 → 0.0.44

package/src/cmd/secret/import.ts

@@ -0,0 +1,64 @@
+import { z } from 'zod';
+import { createSubcommand } from '../../types';
+import * as tui from '../../tui';
+import { projectEnvUpdate } from '@agentuity/server';
+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',
+	requires: { auth: true, project: true, apiClient: true },
+	schema: {
+		args: z.object({
+			file: z.string().describe('path to the .env file to import'),
+		}),
+	},
+
+	async handler(ctx) {
+		const { args, apiClient, project, projectDir } = ctx;
+
+		// 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;
+		}
+
+		// Push to cloud (using secrets field)
+		await tui.spinner('Importing secrets to cloud', () => {
+			return projectEnvUpdate(apiClient, {
+				id: project.projectId,
+				secrets: filteredSecrets,
+			});
+		});
+
+		// Merge with local .env.production file
+		const localEnvPath = await findEnvFile(projectDir);
+		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,56 @@
+import { z } from 'zod';
+import { createSubcommand } from '../../types';
+import * as tui from '../../tui';
+import { projectGet } from '@agentuity/server';
+import { maskSecret } from '../../env-util';
+
+export const listSubcommand = createSubcommand({
+	name: 'list',
+	aliases: ['ls'],
+	description: 'List all secrets',
+	requires: { auth: true, project: true, apiClient: true },
+	schema: {
+		options: z.object({
+			mask: z
+				.boolean()
+				.default(!!process.stdout.isTTY)
+				.describe('mask the values in output (default: true in TTY for secrets)'),
+		}),
+	},
+
+	async handler(ctx) {
+		const { opts, apiClient, project } = ctx;
+
+		// Fetch project with unmasked secrets
+		const projectData = await tui.spinner('Fetching secrets', () => {
+			return projectGet(apiClient, { id: project.projectId, mask: false });
+		});
+
+		const secrets = projectData.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}`);
+			}
+		}
+	},
+});

package/src/cmd/secret/pull.ts

@@ -0,0 +1,78 @@
+import { z } from 'zod';
+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';
+
+export const pullSubcommand = createSubcommand({
+	name: 'pull',
+	description: 'Pull secrets from cloud to local .env.production file',
+	requires: { auth: true, project: true, apiClient: true },
+	schema: {
+		options: z.object({
+			force: z.boolean().default(false).describe('overwrite local values with cloud values'),
+		}),
+	},
+
+	async handler(ctx) {
+		const { opts, apiClient, project, projectDir } = ctx;
+
+		// Fetch project with unmasked secrets
+		const projectData = await tui.spinner('Pulling secrets from cloud', () => {
+			return projectGet(apiClient, { id: project.projectId, mask: false });
+		});
+
+		const cloudSecrets = projectData.secrets || {};
+
+		// 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);
+
+		// 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, cloudSecrets);
+		} else {
+			// Local values take priority (only add new keys from cloud)
+			mergedEnv = mergeEnvVars(cloudSecrets, 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 (projectData.api_key) {
+			const dotEnvPath = join(projectDir, '.env');
+			const dotEnv = await readEnvFile(dotEnvPath);
+
+			if (!dotEnv.AGENTUITY_SDK_KEY) {
+				dotEnv.AGENTUITY_SDK_KEY = projectData.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(cloudSecrets).length;
+		tui.success(`Pulled ${count} secret${count !== 1 ? 's' : ''} to ${targetEnvPath}`);
+	},
+});

package/src/cmd/secret/push.ts

@@ -0,0 +1,37 @@
+import { createSubcommand } from '../../types';
+import * as tui from '../../tui';
+import { projectEnvUpdate } from '@agentuity/server';
+import { findEnvFile, readEnvFile, filterAgentuitySdkKeys } from '../../env-util';
+
+export const pushSubcommand = createSubcommand({
+	name: 'push',
+	description: 'Push secrets from local .env.production file to cloud',
+	requires: { auth: true, project: true, apiClient: true },
+
+	async handler(ctx) {
+		const { apiClient, project, projectDir } = ctx;
+
+		// Read local env file
+		const envFilePath = await findEnvFile(projectDir);
+		const localEnv = await readEnvFile(envFilePath);
+
+		// Filter out AGENTUITY_ prefixed keys (don't push SDK keys)
+		const filteredSecrets = filterAgentuitySdkKeys(localEnv);
+
+		if (Object.keys(filteredSecrets).length === 0) {
+			tui.warning('No secrets to push');
+			return;
+		}
+
+		// Push to cloud (using secrets field)
+		await tui.spinner('Pushing secrets to cloud', () => {
+			return projectEnvUpdate(apiClient, {
+				id: project.projectId,
+				secrets: filteredSecrets,
+			});
+		});
+
+		const count = Object.keys(filteredSecrets).length;
+		tui.success(`Pushed ${count} secret${count !== 1 ? 's' : ''} to cloud`);
+	},
+});

package/src/cmd/secret/set.ts

@@ -0,0 +1,45 @@
+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';
+
+export const setSubcommand = createSubcommand({
+	name: 'set',
+	description: 'Set a secret',
+	requires: { auth: true, project: true, apiClient: true },
+	schema: {
+		args: z.object({
+			key: z.string().min(1, 'key must not be empty').describe('the secret key'),
+			value: z.string().min(1, 'value must not be empty').describe('the secret value'),
+		}),
+	},
+
+	async handler(ctx) {
+		const { args, apiClient, project, projectDir } = ctx;
+
+		// 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.');
+		}
+
+		// Set in cloud (using secrets field)
+		await tui.spinner('Setting secret in cloud', () => {
+			return projectEnvUpdate(apiClient, {
+				id: project.projectId,
+				secrets: { [args.key]: args.value },
+			});
+		});
+
+		// Update local .env.production file
+		const envFilePath = await findEnvFile(projectDir);
+		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(`Secret '${args.key}' set successfully (cloud + ${envFilePath})`);
+	},
+});

package/src/cmd/version/index.ts

@@ -1,6 +1,6 @@
 import { createCommand } from '../../types';
 import { getVersion } from '../../version';
-import { logger } from '../../logger';
+import { createLogger } from '@agentuity/server';
 
 export const command = createCommand({
 	name: 'version',
@@ -10,6 +10,7 @@ export const command = createCommand({
 		try {
 			console.log(getVersion());
 		} catch (error) {
+			const logger = createLogger();
 			logger.fatal('Failed to retrieve version: %s', error);
 		}
 	},