@agentuity/cli 0.0.42 → 0.0.44

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 } from 'node:path';
+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) {
@@ -189,8 +232,18 @@ export async function saveConfig(config: Config, customPath?: string): Promise<v
 	await chmod(configPath, 0o600);
 }
 
+async function getOrInitConfig(): Promise<Config> {
+	const config = await loadConfig();
+	if (config) {
+		return config;
+	}
+	const profilePath = await getProfile();
+	const name = basename(profilePath, '.yaml');
+	return { name };
+}
+
 export async function saveAuth(auth: AuthData): Promise<void> {
-	const config = (await loadConfig()) || { name: 'default' };
+	const config = await getOrInitConfig();
 	config.auth = {
 		api_key: auth.apiKey,
 		user_id: auth.userId,
@@ -202,7 +255,7 @@ export async function saveAuth(auth: AuthData): Promise<void> {
 }
 
 export async function clearAuth(): Promise<void> {
-	const config = (await loadConfig()) || { name: 'default' };
+	const config = await getOrInitConfig();
 	config.auth = {
 		api_key: '',
 		user_id: '',
@@ -213,7 +266,31 @@ export async function clearAuth(): Promise<void> {
 	await saveConfig(config);
 }
 
+export async function saveProjectDir(projectDir: string): Promise<void> {
+	const config = await getOrInitConfig();
+	config.preferences = config.preferences || {};
+	const normalized = resolve(normalize(projectDir));
+	(config.preferences as Record<string, unknown>).project_dir = normalized;
+	await saveConfig(config);
+}
+
+export async function saveOrgId(orgId: string): Promise<void> {
+	const config = await getOrInitConfig();
+	config.preferences = config.preferences || {};
+	(config.preferences as Record<string, unknown>).orgId = orgId;
+	await saveConfig(config);
+}
+
 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;
@@ -255,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[] = [];
 
@@ -325,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) {
@@ -350,16 +548,18 @@ 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');
 
 	const envPath = join(dir, '.env');
-	const envFile = Bun.file(envPath);
-	await envFile.write(`AGENTUITY_SDK_KEY=${apiKey}`);
+	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);
+	await chmod(envPath, 0o600);
 }
 
 export async function loadBuildMetadata(dir: string): Promise<BuildMetadata> {
@@ -381,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;
+}