@agentuity/cli 0.0.43 → 0.0.45

package/src/cmd/secret/pull.ts

@@ -3,8 +3,6 @@ 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,
@@ -16,40 +14,29 @@ import {
 export const pullSubcommand = createSubcommand({
 	name: 'pull',
 	description: 'Pull secrets from cloud to local .env.production file',
-	requiresAuth: true,
+	requires: { auth: true, project: true, apiClient: 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);
+		const { opts, apiClient, project, projectDir } = ctx;
 
 		// Fetch project with unmasked secrets
-		const project = await tui.spinner('Pulling secrets from cloud', () => {
-			return projectGet(client, { id: projectConfig.projectId, mask: false });
+		const projectData = await tui.spinner('Pulling secrets from cloud', () => {
+			return projectGet(apiClient, { id: project.projectId, mask: false });
 		});
 
-		const cloudSecrets = project.secrets || {};
+		const cloudSecrets = projectData.secrets || {};
 
 		// Read current local env from existing file (.env.production or .env)
-		const existingEnvPath = await findExistingEnvFile(dir);
+		const existingEnvPath = await findExistingEnvFile(projectDir);
 		const localEnv = await readEnvFile(existingEnvPath);
 
 		// Target file is always .env.production
-		const targetEnvPath = await findEnvFile(dir);
+		const targetEnvPath = await findEnvFile(projectDir);
 
 		// Merge: cloud values override local if force=true, otherwise keep local
 		let mergedEnv: Record<string, string>;
@@ -67,12 +54,12 @@ export const pullSubcommand = createSubcommand({
 		});
 
 		// Write AGENTUITY_SDK_KEY to .env if present and missing locally
-		if (project.api_key) {
-			const dotEnvPath = join(dir, '.env');
+		if (projectData.api_key) {
+			const dotEnvPath = join(projectDir, '.env');
 			const dotEnv = await readEnvFile(dotEnvPath);
 
 			if (!dotEnv.AGENTUITY_SDK_KEY) {
-				dotEnv.AGENTUITY_SDK_KEY = project.api_key;
+				dotEnv.AGENTUITY_SDK_KEY = projectData.api_key;
 				await writeEnvFile(dotEnvPath, dotEnv, {
 					addComment: (key) => {
 						if (key === 'AGENTUITY_SDK_KEY') {

package/src/cmd/secret/push.ts

@@ -1,33 +1,18 @@
-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, filterAgentuitySdkKeys } from '../../env-util';
 
 export const pushSubcommand = createSubcommand({
 	name: 'push',
 	description: 'Push secrets from local .env.production file to cloud',
-	requiresAuth: true,
-	schema: {
-		options: z.object({
-			dir: z.string().optional().describe('project directory (default: current directory)'),
-		}),
-	},
+	requires: { auth: true, project: true, apiClient: true },
 
 	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 { apiClient, project, projectDir } = ctx;
 
 		// Read local env file
-		const envFilePath = await findEnvFile(dir);
+		const envFilePath = await findEnvFile(projectDir);
 		const localEnv = await readEnvFile(envFilePath);
 
 		// Filter out AGENTUITY_ prefixed keys (don't push SDK keys)
@@ -38,13 +23,10 @@ export const pushSubcommand = createSubcommand({
 			return;
 		}
 
-		const apiUrl = getAPIBaseURL(config);
-		const client = new APIClient(apiUrl, config);
-
 		// Push to cloud (using secrets field)
 		await tui.spinner('Pushing secrets to cloud', () => {
-			return projectEnvUpdate(client, {
-				id: projectConfig.projectId,
+			return projectEnvUpdate(apiClient, {
+				id: project.projectId,
 				secrets: filteredSecrets,
 			});
 		});

package/src/cmd/secret/set.ts

@@ -2,52 +2,37 @@ 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 } from '../../env-util';
 
 export const setSubcommand = createSubcommand({
 	name: 'set',
 	description: 'Set a secret',
-	requiresAuth: true,
+	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'),
 		}),
-		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();
+		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.');
 		}
 
-		// 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 (using secrets field)
 		await tui.spinner('Setting secret in cloud', () => {
-			return projectEnvUpdate(client, {
-				id: projectConfig.projectId,
+			return projectEnvUpdate(apiClient, {
+				id: project.projectId,
 				secrets: { [args.key]: args.value },
 			});
 		});
 
 		// Update local .env.production file
-		const envFilePath = await findEnvFile(dir);
+		const envFilePath = await findEnvFile(projectDir);
 		const currentEnv = await readEnvFile(envFilePath);
 		currentEnv[args.key] = args.value;
 

package/src/config.ts

@@ -1,18 +1,29 @@
+import { z } from 'zod';
+import { existsSync } from 'node:fs';
+import type { Logger } from '@agentuity/core';
+import {
+	BuildMetadataSchema,
+	type BuildMetadata,
+	getServiceUrls,
+	APIClient as ServerAPIClient,
+} from '@agentuity/server';
 import { YAML } from 'bun';
 import { join, extname, basename, resolve, normalize } from 'node:path';
 import { homedir } from 'node:os';
 import { mkdir, readdir, readFile, writeFile, chmod } from 'node:fs/promises';
+import JSON5 from 'json5';
 import type { Config, Profile, AuthData } from './types';
-import { ConfigSchema, ProjectSchema, BuildMetadataSchema, type BuildMetadata } from './types';
+import { ConfigSchema, ProjectSchema } from './types';
 import * as tui from './tui';
-import { z } from 'zod';
+
+export const defaultProfileName = 'production';
 
 export function getDefaultConfigDir(): string {
 	return join(homedir(), '.config', 'agentuity');
 }
 
 export function getDefaultConfigPath(): string {
-	return join(getDefaultConfigDir(), 'production.yaml');
+	return join(getDefaultConfigDir(), defaultProfileName + '.yaml');
 }
 
 export function getProfilePath(): string {
@@ -71,7 +82,7 @@ export async function fetchProfiles(): Promise<Profile[]> {
 					const content = await readFile(filePath, 'utf-8');
 					const match = nameRegex.exec(content);
 
-					if (match && match[1]) {
+					if (match?.[1]) {
 						profiles.push({
 							name: match[1],
 							filename: filePath,
@@ -103,22 +114,24 @@ export async function loadConfig(customPath?: string): Promise<Config | null> {
 	try {
 		const file = Bun.file(configPath);
 		const exists = await file.exists();
+		let result: ReturnType<typeof ConfigSchema.safeParse>;
 
-		if (!exists) {
-			return null;
-		}
+		if (exists) {
+			const content = await file.text();
+			const config = YAML.parse(content);
 
-		const content = await file.text();
-		const config = YAML.parse(content);
+			// check to see if this is a legacy config file that might not have the required name
+			// and in this case we can just use the filename
+			const _config = config as { name?: string };
+			if (!_config.name) {
+				_config.name = basename(configPath).replace(extname(configPath), '');
+			}
 
-		// check to see if this is a legacy config file that might not have the required name
-		// and in this case we can just use the filename
-		const _config = config as { name?: string };
-		if (!_config.name) {
-			_config.name = basename(configPath).replace(extname(configPath), '');
+			result = ConfigSchema.safeParse(config);
+		} else {
+			result = ConfigSchema.safeParse({ name: defaultProfileName });
 		}
 
-		const result = ConfigSchema.safeParse(config);
 		if (!result.success) {
 			tui.error(`Invalid config in ${configPath}:`);
 			for (const issue of result.error.issues) {
@@ -128,6 +141,36 @@ export async function loadConfig(customPath?: string): Promise<Config | null> {
 			process.exit(1);
 		}
 
+		// allow environment variables to override
+		const overrides = result.data.overrides ?? ConfigSchema.shape.overrides.parse({});
+		if (overrides) {
+			if (process.env.AGENTUITY_API_URL) {
+				overrides.api_url = process.env.AGENTUITY_API_URL;
+			}
+			if (process.env.AGENTUITY_APP_URL) {
+				overrides.app_url = process.env.AGENTUITY_APP_URL;
+			}
+			if (process.env.AGENTUITY_CATALYST_URL) {
+				overrides.catalyst_url = process.env.AGENTUITY_CATALYST_URL;
+			}
+			if (process.env.AGENTUITY_TRANSPORT_URL) {
+				overrides.transport_url = process.env.AGENTUITY_TRANSPORT_URL;
+			}
+			if (process.env.AGENTUITY_KEYVALUE_URL) {
+				overrides.kv_url = process.env.AGENTUITY_KEYVALUE_URL;
+			}
+			if (process.env.AGENTUITY_OBJECTSTORE_URL) {
+				overrides.object_url = process.env.AGENTUITY_OBJECTSTORE_URL;
+			}
+			if (process.env.AGENTUITY_VECTOR_URL) {
+				overrides.vector_url = process.env.AGENTUITY_VECTOR_URL;
+			}
+			if (process.env.AGENTUITY_STREAM_URL) {
+				overrides.stream_url = process.env.AGENTUITY_STREAM_URL;
+			}
+			result.data.overrides = overrides;
+		}
+
 		return result.data;
 	} catch (error) {
 		if (error instanceof Error) {
@@ -239,6 +282,15 @@ export async function saveOrgId(orgId: string): Promise<void> {
 }
 
 export async function getAuth(): Promise<AuthData | null> {
+	// allow automated login from environment variables if present
+	if (process.env.AGENTUITY_CLI_API_KEY && process.env.AGENTUITY_USER_ID) {
+		return {
+			apiKey: process.env.AGENTUITY_CLI_API_KEY,
+			userId: process.env.AGENTUITY_USER_ID,
+			expires: new Date(Date.now() + 30 * 60_000),
+		};
+	}
+
 	const config = await loadConfig();
 	if (!config) return null;
 	const auth = config.auth as { api_key?: string; user_id?: string; expires?: number } | undefined;
@@ -280,6 +332,81 @@ function getPlaceholderValue(schema: z.ZodTypeAny): string {
 	}
 }
 
+function extractDefaultValue(schema: z.ZodTypeAny): unknown {
+	let unwrapped = schema;
+
+	// Unwrap optional layers
+	while (unwrapped instanceof z.ZodOptional) {
+		unwrapped = (unwrapped._def as unknown as { innerType: z.ZodTypeAny }).innerType;
+	}
+
+	// Check if it's a ZodDefault (has defaultValue in def or _def)
+	const checkDef = (obj: unknown): unknown => {
+		if (typeof obj !== 'object' || obj === null) return undefined;
+		const anyObj = obj as Record<string, unknown>;
+
+		// Check `def` property first (used in some Zod versions)
+		if ('def' in anyObj && typeof anyObj.def === 'object' && anyObj.def !== null) {
+			const def = anyObj.def as Record<string, unknown>;
+			if (def.type === 'default' && 'defaultValue' in def) {
+				const val = def.defaultValue;
+				return typeof val === 'function' ? (val as () => unknown)() : val;
+			}
+		}
+
+		// Check `_def` property (standard Zod property)
+		if ('_def' in anyObj && typeof anyObj._def === 'object' && anyObj._def !== null) {
+			const def = anyObj._def as Record<string, unknown>;
+			if (def.type === 'default' && 'defaultValue' in def) {
+				const val = def.defaultValue;
+				return typeof val === 'function' ? (val as () => unknown)() : val;
+			}
+		}
+
+		return undefined;
+	};
+
+	return checkDef(unwrapped);
+}
+
+function getValueWithDefaults(schema: z.ZodTypeAny, providedValue: unknown): unknown {
+	// If value is explicitly provided, use it
+	if (providedValue !== undefined) {
+		return providedValue;
+	}
+
+	// Try to extract default value
+	const defaultValue = extractDefaultValue(schema);
+	if (defaultValue !== undefined) {
+		return defaultValue;
+	}
+
+	// For optional fields without defaults, check if it's an object
+	let unwrapped = schema;
+	if (schema instanceof z.ZodOptional) {
+		unwrapped = (schema._def as unknown as { innerType: z.ZodTypeAny }).innerType;
+	}
+
+	// If it's an object schema, recursively populate defaults
+	if (unwrapped instanceof z.ZodObject) {
+		const shape = unwrapped.shape;
+		const result: Record<string, unknown> = {};
+		let hasAnyDefaults = false;
+
+		for (const [key, fieldSchema] of Object.entries(shape)) {
+			const fieldValue = getValueWithDefaults(fieldSchema as z.ZodTypeAny, undefined);
+			if (fieldValue !== undefined) {
+				result[key] = fieldValue;
+				hasAnyDefaults = true;
+			}
+		}
+
+		return hasAnyDefaults ? result : undefined;
+	}
+
+	return undefined;
+}
+
 export function generateYAMLTemplate(name: string): string {
 	const lines: string[] = [];
 
@@ -350,15 +477,61 @@ class ProjectConfigNotFoundExpection extends Error {
 
 type ProjectConfig = z.infer<typeof ProjectSchema>;
 
-export async function loadProjectConfig(dir: string): Promise<ProjectConfig> {
-	const configPath = join(dir, 'agentuity.json');
+function generateJSON5WithComments(
+	schema: z.ZodObject<z.ZodRawShape>,
+	data: Record<string, unknown>
+): string {
+	const lines: string[] = ['{'];
+	const shape = schema.shape;
+	const keys = Object.keys(shape);
+
+	for (let i = 0; i < keys.length; i++) {
+		const key = keys[i];
+		const fieldSchema = shape[key] as z.ZodTypeAny;
+		const description = getSchemaDescription(fieldSchema);
+		const providedValue = data[key];
+
+		if (description) {
+			lines.push(`  // ${description}`);
+		}
+
+		// Get value with defaults applied
+		const valueWithDefaults = getValueWithDefaults(fieldSchema, providedValue);
+		const safeValue = valueWithDefaults === undefined ? null : valueWithDefaults;
+		const jsonValue = JSON.stringify(safeValue, null, 2).replace(/\n/g, '\n  ');
+		const comma = i < keys.length - 1 ? ',' : '';
+		lines.push(`  ${JSON.stringify(key)}: ${jsonValue}${comma}`);
+	}
+
+	lines.push('}');
+	return lines.join('\n');
+}
+
+export async function loadProjectConfig(
+	dir: string,
+	config?: Config | null
+): Promise<ProjectConfig> {
+	let configPath = join(dir, 'agentuity.json');
+
+	// Check for profile-specific override if config is provided
+	if (config?.name) {
+		const profileConfigPath = join(dir, `agentuity.${config.name}.json`);
+		if (await Bun.file(profileConfigPath).exists()) {
+			configPath = profileConfigPath;
+		}
+	}
+
 	const file = Bun.file(configPath);
 	if (!(await file.exists())) {
+		// TODO: check to see if a valid project that was created unauthenticated
+		// and then if so:
+		// 1. if authentication, offer to import the project
+		// 2. tell them that they need to login to use the command and import the project
 		throw new ProjectConfigNotFoundExpection();
 	}
 	const text = await file.text();
-	const config = JSON.parse(text);
-	const result = ProjectSchema.safeParse(config);
+	const parsedConfig = JSON5.parse(text);
+	const result = ProjectSchema.safeParse(parsedConfig);
 	if (!result.success) {
 		tui.error(`Invalid project config at ${configPath}:`);
 		for (const issue of result.error.issues) {
@@ -375,20 +548,17 @@ type InitialProjectConfig = ProjectConfig & {
 };
 
 export async function createProjectConfig(dir: string, config: InitialProjectConfig) {
-	// Create a sanitized config without the apiKey for agentuity.json
 	const { apiKey, ...sanitizedConfig } = config;
 
 	const configPath = join(dir, 'agentuity.json');
-	const configFile = Bun.file(configPath);
-	await configFile.write(JSON.stringify(sanitizedConfig, null, 2));
+	const json5Content = generateJSON5WithComments(ProjectSchema, sanitizedConfig);
+	await Bun.write(configPath, json5Content + '\n');
 
-	// Write SDK key to .env with comment
 	const envPath = join(dir, '.env');
 	const comment =
 		'# AGENTUITY_SDK_KEY is a sensitive value and should not be committed to version control.';
 	const content = `${comment}\nAGENTUITY_SDK_KEY=${apiKey}\n`;
 	await Bun.write(envPath, content);
-	// Set restrictive permissions (owner read/write only) to protect sensitive key
 	await chmod(envPath, 0o600);
 }
 
@@ -411,3 +581,33 @@ export async function loadBuildMetadata(dir: string): Promise<BuildMetadata> {
 	}
 	return result.data;
 }
+
+export async function loadDevelopmentProjectSDKKey(
+	projectDir: string
+): Promise<string | undefined> {
+	const files: string[] = ['.env.development', '.env.local', '.env'];
+	for (const filename of files) {
+		const fn = join(projectDir, filename);
+		if (existsSync(fn)) {
+			const buf = await Bun.file(fn).text();
+			const tok = buf.split(/\n/);
+			for (const t of tok) {
+				if (t.charAt(0) !== '#' && t.startsWith('AGENTUITY_SDK_KEY=')) {
+					const i = t.indexOf('=');
+					return t.substring(i + 1).trim();
+				}
+			}
+		}
+	}
+}
+
+export function getCatalystAPIClient(config: Config | null, logger: Logger, auth: AuthData) {
+	const serviceUrls = getServiceUrls();
+	const catalystUrl = config?.overrides?.catalyst_url ?? serviceUrls.catalyst;
+	return new ServerAPIClient(catalystUrl, logger, auth.apiKey);
+}
+
+export function getIONHost(config: Config | null) {
+	const url = new URL(config?.overrides?.ion_url ?? 'https://ion.agentuity.cloud');
+	return url.hostname;
+}