@agentuity/cli 0.0.42 → 0.0.43

package/src/cmd/secret/set.ts

@@ -0,0 +1,60 @@
+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,
+	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();
+
+		// 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,
+				secrets: { [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(`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);
 		}
 	},

package/src/config.ts

@@ -1,5 +1,5 @@
 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 type { Config, Profile, AuthData } from './types';
@@ -189,8 +189,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 +212,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,6 +223,21 @@ 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> {
 	const config = await loadConfig();
 	if (!config) return null;
@@ -357,9 +382,14 @@ export async function createProjectConfig(dir: string, config: InitialProjectCon
 	const configFile = Bun.file(configPath);
 	await configFile.write(JSON.stringify(sanitizedConfig, null, 2));
 
+	// Write SDK key to .env with comment
 	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);
+	// Set restrictive permissions (owner read/write only) to protect sensitive key
+	await chmod(envPath, 0o600);
 }
 
 export async function loadBuildMetadata(dir: string): Promise<BuildMetadata> {

package/src/env-util.test.ts

@@ -0,0 +1,194 @@
+import { describe, test, expect } from 'bun:test';
+import { looksLikeSecret } from './env-util';
+
+describe('looksLikeSecret', () => {
+	describe('key name patterns', () => {
+		test('detects _SECRET suffix', () => {
+			expect(looksLikeSecret('API_SECRET', 'value')).toBe(true);
+			expect(looksLikeSecret('DB_SECRET', 'value')).toBe(true);
+		});
+
+		test('detects _KEY suffix', () => {
+			expect(looksLikeSecret('API_KEY', 'value')).toBe(true);
+			expect(looksLikeSecret('STRIPE_KEY', 'value')).toBe(true);
+		});
+
+		test('detects _TOKEN suffix', () => {
+			expect(looksLikeSecret('AUTH_TOKEN', 'value')).toBe(true);
+			expect(looksLikeSecret('GITHUB_TOKEN', 'value')).toBe(true);
+		});
+
+		test('detects _PASSWORD suffix', () => {
+			expect(looksLikeSecret('DB_PASSWORD', 'value')).toBe(true);
+			expect(looksLikeSecret('ADMIN_PASSWORD', 'value')).toBe(true);
+		});
+
+		test('detects _PRIVATE suffix', () => {
+			expect(looksLikeSecret('SSH_PRIVATE', 'value')).toBe(true);
+		});
+
+		test('detects _CERT and _CERTIFICATE suffixes', () => {
+			expect(looksLikeSecret('SSL_CERT', 'value')).toBe(true);
+			expect(looksLikeSecret('SSL_CERTIFICATE', 'value')).toBe(true);
+		});
+
+		test('detects SECRET_ prefix', () => {
+			expect(looksLikeSecret('SECRET_VALUE', 'value')).toBe(true);
+		});
+
+		test('detects APIKEY and API_KEY patterns', () => {
+			expect(looksLikeSecret('APIKEY', 'value')).toBe(true);
+			expect(looksLikeSecret('API_KEY', 'value')).toBe(true);
+		});
+
+		test('detects JWT prefix', () => {
+			expect(looksLikeSecret('JWT_SECRET', 'value')).toBe(true);
+			expect(looksLikeSecret('JWT', 'value')).toBe(true);
+		});
+
+		test('detects PASSWORD in key name', () => {
+			expect(looksLikeSecret('DATABASE_PASSWORD', 'value')).toBe(true);
+			expect(looksLikeSecret('PASSWORD', 'value')).toBe(true);
+		});
+
+		test('detects CREDENTIAL in key name', () => {
+			expect(looksLikeSecret('AWS_CREDENTIALS', 'value')).toBe(true);
+		});
+
+		test('detects AUTH.*KEY pattern', () => {
+			expect(looksLikeSecret('AUTH_API_KEY', 'value')).toBe(true);
+			expect(looksLikeSecret('AUTHKEY', 'value')).toBe(true);
+		});
+
+		test('is case insensitive for key patterns', () => {
+			expect(looksLikeSecret('api_secret', 'value')).toBe(true);
+			expect(looksLikeSecret('Api_Key', 'value')).toBe(true);
+			expect(looksLikeSecret('AUTH_token', 'value')).toBe(true);
+		});
+	});
+
+	describe('value patterns', () => {
+		test('detects JWT tokens', () => {
+			const jwt =
+				'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c';
+			expect(looksLikeSecret('TOKEN', jwt)).toBe(true);
+			expect(looksLikeSecret('SOME_VAR', jwt)).toBe(true);
+		});
+
+		test('detects Bearer tokens', () => {
+			expect(looksLikeSecret('AUTH', 'Bearer abc123def456ghi789jkl012mno345pqr')).toBe(true);
+		});
+
+		test('detects AWS access keys', () => {
+			expect(looksLikeSecret('AWS', 'AKIAIOSFODNN7EXAMPLE')).toBe(true);
+			expect(looksLikeSecret('AWS', 'ASIAIOSFODNN7EXAMPLE')).toBe(true);
+		});
+
+		test('detects GitHub tokens', () => {
+			expect(looksLikeSecret('GH', 'ghp_1234567890abcdefghijklmnopqrstuvwxyz')).toBe(true);
+			expect(looksLikeSecret('GH', 'ghs_1234567890abcdefghijklmnopqrstuvwxyz')).toBe(true);
+		});
+
+		test('detects long alphanumeric strings (API keys)', () => {
+			// 32+ characters, mixed alphanumeric
+			expect(
+				looksLikeSecret('KEY', 'sk_test_51A1B2C3D4E5F6G7H8I9J0K1L2M3N4O5P6Q7R8S9T0U1V2W3X4Y5Z6')
+			).toBe(true);
+			expect(looksLikeSecret('KEY', 'abc123def456ghi789jkl012mno345pqr678stu901vwx234yz')).toBe(
+				true
+			);
+		});
+
+		test('does not flag numeric-only long strings', () => {
+			expect(looksLikeSecret('ID', '12345678901234567890123456789012')).toBe(false);
+		});
+
+		test('detects PEM certificates', () => {
+			expect(looksLikeSecret('CERT', '-----BEGIN CERTIFICATE-----\nMIIC...')).toBe(true);
+			expect(looksLikeSecret('CERT', '-----BEGIN PRIVATE KEY-----\nMIIC...')).toBe(true);
+			expect(looksLikeSecret('CERT', '-----BEGIN RSA PRIVATE KEY-----\nMIIC...')).toBe(true);
+		});
+
+		test('does not flag short values', () => {
+			expect(looksLikeSecret('VAR', 'short')).toBe(false);
+			expect(looksLikeSecret('VAR', '1234567')).toBe(false);
+		});
+
+		test('does not flag empty values', () => {
+			expect(looksLikeSecret('VAR', '')).toBe(false);
+		});
+	});
+
+	describe('non-secret patterns', () => {
+		test('regular environment variables are not flagged', () => {
+			expect(looksLikeSecret('NODE_ENV', 'production')).toBe(false);
+			expect(looksLikeSecret('PORT', '3000')).toBe(false);
+			expect(looksLikeSecret('HOST', 'localhost')).toBe(false);
+			expect(looksLikeSecret('DATABASE_URL', 'postgres://localhost:5432/mydb')).toBe(false);
+		});
+
+		test('configuration values are not flagged', () => {
+			expect(looksLikeSecret('LOG_LEVEL', 'debug')).toBe(false);
+			expect(looksLikeSecret('CACHE_TTL', '3600')).toBe(false);
+			expect(looksLikeSecret('MAX_CONNECTIONS', '100')).toBe(false);
+		});
+
+		test('URLs without secrets are not flagged', () => {
+			expect(looksLikeSecret('API_URL', 'https://api.example.com')).toBe(false);
+			expect(looksLikeSecret('WEBHOOK_URL', 'https://example.com/webhook')).toBe(false);
+		});
+
+		test('paths are not flagged', () => {
+			expect(looksLikeSecret('DATA_PATH', '/var/data/app')).toBe(false);
+			expect(looksLikeSecret('CONFIG_FILE', '/etc/app/config.json')).toBe(false);
+		});
+	});
+
+	describe('edge cases', () => {
+		test('handles mixed key and value patterns', () => {
+			// Key pattern triggers detection
+			expect(looksLikeSecret('API_KEY', 'simple')).toBe(true);
+
+			// Value pattern triggers detection even without key pattern
+			const jwt =
+				'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c';
+			expect(looksLikeSecret('CONFIG', jwt)).toBe(true);
+		});
+
+		test('real-world API key formats', () => {
+			// Stripe (contains underscore, 32+ chars)
+			expect(looksLikeSecret('STRIPE', 'sk_test_51HqL7xAbCdEfGhIjK12345678901234567890')).toBe(
+				true
+			);
+
+			// Long API key format (32+ alphanumeric)
+			expect(looksLikeSecret('OPENAI', 'sk-proj-1234567890abcdefghijklmnopqrstuvwxyz')).toBe(
+				true
+			);
+
+			// Contains dots (periods not in our pattern, but key name helps)
+			expect(
+				looksLikeSecret(
+					'SENDGRID_API_KEY',
+					'SG.1234567890abcdefghijklmnopqrstuvwxyz.1234567890abcdefghijklmnopqrstuvwxyz'
+				)
+			).toBe(true);
+		});
+
+		test('UUIDs are correctly identified as non-secrets', () => {
+			// Standard UUID format should not be flagged
+			expect(looksLikeSecret('REQUEST_ID', '550e8400-e29b-41d4-a716-446655440000')).toBe(false);
+			expect(looksLikeSecret('USER_ID', '123e4567-e89b-12d3-a456-426614174000')).toBe(false);
+		});
+
+		test('hex hashes are flagged (better safe than sorry)', () => {
+			// 32+ character hex strings could be secrets or hashes - we flag them
+			// Users can confirm they're just hashes if needed
+			expect(looksLikeSecret('BUILD_HASH', 'a1b2c3d4e5f6g7h8i9j0k1l2m3n4o5p6')).toBe(true);
+
+			// But with context that clearly indicates it's not a secret, the key name won't trigger
+			// So short hex strings without secret-like key names won't be flagged
+			expect(looksLikeSecret('COMMIT', 'abc123def')).toBe(false);
+		});
+	});
+});

package/src/env-util.ts

@@ -0,0 +1,290 @@
+/**
+ * Utility functions for handling .env files
+ */
+
+import { join } from 'node:path';
+
+export interface EnvVars {
+	[key: string]: string;
+}
+
+/**
+ * Find the appropriate .env file to use for user environment variables.
+ * Always returns .env.production path (will be created if needed).
+ * .env should only contain AGENTUITY_SDK_KEY.
+ */
+export async function findEnvFile(dir: string): Promise<string> {
+	return join(dir, '.env.production');
+}
+
+/**
+ * Find an existing env file for reading.
+ * Preference: .env.production > .env
+ */
+export async function findExistingEnvFile(dir: string): Promise<string> {
+	const productionEnv = join(dir, '.env.production');
+	const defaultEnv = join(dir, '.env');
+
+	if (await Bun.file(productionEnv).exists()) {
+		return productionEnv;
+	}
+
+	return defaultEnv;
+}
+
+/**
+ * Parse a single line from an .env file
+ * Handles comments, empty lines, and quoted values
+ */
+export function parseEnvLine(line: string): { key: string; value: string } | null {
+	const trimmed = line.trim();
+
+	// Skip empty lines and comments
+	if (!trimmed || trimmed.startsWith('#')) {
+		return null;
+	}
+
+	const equalIndex = trimmed.indexOf('=');
+	if (equalIndex === -1) {
+		return null;
+	}
+
+	const key = trimmed.slice(0, equalIndex).trim();
+	let value = trimmed.slice(equalIndex + 1).trim();
+
+	// Remove surrounding quotes if present
+	if (
+		(value.startsWith('"') && value.endsWith('"')) ||
+		(value.startsWith("'") && value.endsWith("'"))
+	) {
+		value = value.slice(1, -1);
+	}
+
+	return { key, value };
+}
+
+/**
+ * Read and parse an .env file
+ */
+export async function readEnvFile(path: string): Promise<EnvVars> {
+	const file = Bun.file(path);
+
+	if (!(await file.exists())) {
+		return {};
+	}
+
+	const content = await file.text();
+	const lines = content.split('\n');
+	const env: EnvVars = {};
+
+	for (const line of lines) {
+		const parsed = parseEnvLine(line);
+		if (parsed) {
+			env[parsed.key] = parsed.value;
+		}
+	}
+
+	return env;
+}
+
+/**
+ * Write environment variables to an .env file
+ * Optionally skip certain keys (like AGENTUITY_SDK_KEY)
+ */
+export async function writeEnvFile(
+	path: string,
+	vars: EnvVars,
+	options?: {
+		skipKeys?: string[];
+		addComment?: (key: string) => string | null;
+	}
+): Promise<void> {
+	const skipKeys = options?.skipKeys || [];
+	const lines: string[] = [];
+
+	// Sort keys for consistent output
+	const sortedKeys = Object.keys(vars).sort();
+
+	for (const key of sortedKeys) {
+		if (skipKeys.includes(key)) {
+			continue;
+		}
+
+		const value = vars[key];
+
+		// Add comment if provided
+		if (options?.addComment) {
+			const comment = options.addComment(key);
+			if (comment) {
+				lines.push(`# ${comment}`);
+			}
+		}
+
+		// Write key=value
+		lines.push(`${key}=${value}`);
+	}
+
+	const content = lines.join('\n') + '\n';
+	await Bun.write(path, content);
+}
+
+/**
+ * Merge environment variables with special handling
+ * - Later values override earlier values
+ * - Can filter out keys (like AGENTUITY_* keys)
+ */
+export function mergeEnvVars(
+	base: EnvVars,
+	updates: EnvVars,
+	options?: {
+		filterPrefix?: string;
+	}
+): EnvVars {
+	const merged = { ...base };
+	const filterPrefix = options?.filterPrefix;
+
+	for (const [key, value] of Object.entries(updates)) {
+		// Skip keys with filter prefix if specified
+		if (filterPrefix && key.startsWith(filterPrefix)) {
+			continue;
+		}
+
+		merged[key] = value;
+	}
+
+	return merged;
+}
+
+/**
+ * Filter out AGENTUITY_ prefixed keys from env vars
+ * This is used when pushing to the cloud to avoid sending SDK keys
+ */
+export function filterAgentuitySdkKeys(vars: EnvVars): EnvVars {
+	const filtered: EnvVars = {};
+
+	for (const [key, value] of Object.entries(vars)) {
+		if (!key.startsWith('AGENTUITY_')) {
+			filtered[key] = value;
+		}
+	}
+
+	return filtered;
+}
+
+/**
+ * Split env vars into env and secrets based on key names
+ * Convention: Keys ending with _SECRET, _KEY, _TOKEN, _PASSWORD are secrets
+ */
+export function splitEnvAndSecrets(vars: EnvVars): {
+	env: EnvVars;
+	secrets: EnvVars;
+} {
+	const env: EnvVars = {};
+	const secrets: EnvVars = {};
+
+	const secretSuffixes = ['_SECRET', '_KEY', '_TOKEN', '_PASSWORD', '_PRIVATE'];
+
+	for (const [key, value] of Object.entries(vars)) {
+		// Skip AGENTUITY_ prefixed keys
+		if (key.startsWith('AGENTUITY_')) {
+			continue;
+		}
+
+		const isSecret = secretSuffixes.some((suffix) => key.endsWith(suffix));
+
+		if (isSecret) {
+			secrets[key] = value;
+		} else {
+			env[key] = value;
+		}
+	}
+
+	return { env, secrets };
+}
+
+/**
+ * Mask a secret value for display
+ */
+export function maskSecret(value: string): string {
+	if (!value) {
+		return '';
+	}
+
+	if (value.length <= 8) {
+		return '***';
+	}
+
+	// Show first 4 and last 4 characters
+	return `${value.slice(0, 4)}...${value.slice(-4)}`;
+}
+
+/**
+ * Detect if a key or value looks like it should be a secret
+ */
+export function looksLikeSecret(key: string, value: string): boolean {
+	// Check key name for secret-like patterns
+	const secretKeyPatterns = [
+		/_SECRET$/i,
+		/_KEY$/i,
+		/_TOKEN$/i,
+		/_PASSWORD$/i,
+		/_PRIVATE$/i,
+		/_CERT$/i,
+		/_CERTIFICATE$/i,
+		/^SECRET_/i,
+		/^API_?KEY/i,
+		/^JWT/i,
+		/PASSWORD/i,
+		/CREDENTIAL/i,
+		/AUTH.*KEY/i,
+	];
+
+	const keyLooksSecret = secretKeyPatterns.some((pattern) => pattern.test(key));
+	if (keyLooksSecret) {
+		return true;
+	}
+
+	// Check value for secret-like patterns
+	if (!value || value.length < 8) {
+		return false;
+	}
+
+	// JWT pattern (header.payload.signature)
+	if (/^eyJ[A-Za-z0-9_-]+\.eyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+$/.test(value)) {
+		return true;
+	}
+
+	// Bearer token pattern
+	if (/^Bearer\s+[A-Za-z0-9_-]{20,}$/i.test(value)) {
+		return true;
+	}
+
+	// AWS/Cloud provider key patterns
+	if (/^(AKIA|ASIA)[A-Z0-9]{16}$/.test(value)) {
+		// AWS access key
+		return true;
+	}
+
+	// GitHub token patterns
+	if (/^gh[ps]_[A-Za-z0-9_]{36,}$/.test(value)) {
+		return true;
+	}
+
+	// Generic long alphanumeric strings (likely API keys)
+	// Exclude UUIDs (8-4-4-4-12 format) and simple alphanumeric IDs
+	const isUUID = /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/i.test(value);
+	if (!isUUID && /^[A-Za-z0-9_-]{32,}$/.test(value) && !/^[0-9]+$/.test(value)) {
+		return true;
+	}
+
+	// PEM-encoded certificates or private keys
+	if (
+		value.includes('BEGIN CERTIFICATE') ||
+		value.includes('BEGIN PRIVATE KEY') ||
+		value.includes('BEGIN RSA PRIVATE KEY')
+	) {
+		return true;
+	}
+
+	return false;
+}

package/src/index.ts

@@ -17,7 +17,11 @@ export {
 	getAuth,
 } from './config';
 export { APIClient, getAPIBaseURL, getAppBaseURL } from './api';
-export { Logger, logger } from './logger';
+export {
+	ConsoleLogger,
+	createLogger,
+	type ColorScheme as LoggerColorScheme,
+} from '@agentuity/server';
 export { showBanner } from './banner';
 export { discoverCommands } from './cmd';
 export { detectColorScheme } from './terminal';

package/src/schema-parser.ts

@@ -203,9 +203,8 @@ export function buildValidationInput(
 	if (schemas.options) {
 		const parsed = parseOptionsSchema(schemas.options);
 		for (const opt of parsed) {
-			if (rawOptions[opt.name] !== undefined) {
-				result.options[opt.name] = rawOptions[opt.name];
-			}
+			// Always include the option value (even if undefined) so zod can apply defaults
+			result.options[opt.name] = rawOptions[opt.name];
 		}
 	}