@agentuity/cli 0.0.100 → 0.0.102

package/src/cmd/dev/sync.ts

@@ -171,9 +171,21 @@ class DevmodeSyncService implements IDevmodeSyncService {
 		for (const agent of currentMetadata.agents || []) {
 			if (agent.evals) {
 				currentEvalCount += agent.evals.length;
+				this.logger.debug(
+					'[CLI EVAL SYNC] Agent "%s" has %d eval(s)',
+					agent.name,
+					agent.evals.length
+				);
+				for (const evalItem of agent.evals) {
+					this.logger.debug(
+						'[CLI EVAL SYNC]   - %s (evalId: %s)',
+						evalItem.name,
+						evalItem.evalId
+					);
+				}
 			}
 		}
-		this.logger.debug('Processing %d current eval(s)', currentEvalCount);
+		this.logger.debug('[CLI EVAL SYNC] Total current eval(s): %d', currentEvalCount);
 
 		// Get agents and evals to sync using shared diff logic
 		const { create: agentsToCreate, delete: agentsToDelete } = getAgentsToSync(
@@ -261,7 +273,14 @@ class DevmodeSyncService implements IDevmodeSyncService {
 		evalsToDelete: string[],
 		deploymentId: string
 	): Promise<void> {
+		this.logger.info(
+			'[CLI EVAL SYNC] syncEvals called: %d to create, %d to delete',
+			evals.length,
+			evalsToDelete.length
+		);
+
 		if (evals.length === 0 && evalsToDelete.length === 0) {
+			this.logger.debug('[CLI EVAL SYNC] No evals to sync, skipping');
 			return;
 		}
 
@@ -270,12 +289,28 @@ class DevmodeSyncService implements IDevmodeSyncService {
 			create: evals,
 			delete: evalsToDelete,
 		};
-		this.logger.trace(
-			'[CLI EVAL SYNC] Sending payload to POST /cli/devmode/eval: %s',
-			JSON.stringify(payload, null, 2)
-		);
 
-		await this.apiClient.post('/cli/devmode/eval', payload, z.object({ success: z.boolean() }));
+		this.logger.debug('[CLI EVAL SYNC] Sending payload to POST /cli/devmode/eval:');
+		for (const evalItem of evals) {
+			this.logger.debug(
+				'[CLI EVAL SYNC]   - %s (id: %s, evalId: %s)',
+				evalItem.name,
+				evalItem.id,
+				evalItem.evalId
+			);
+		}
+
+		try {
+			await this.apiClient.post(
+				'/cli/devmode/eval',
+				payload,
+				z.object({ success: z.boolean() })
+			);
+			this.logger.debug('[CLI EVAL SYNC] Sync successful');
+		} catch (error) {
+			this.logger.error('[CLI EVAL SYNC] Sync failed: %s', error);
+			throw error;
+		}
 	}
 }
 

package/src/cmd/index.ts

@@ -39,6 +39,7 @@ export async function discoverCommands(): Promise<CommandDefinition[]> {
 						description: subcommand.description,
 						aliases: subcommand.aliases,
 						hidden: true,
+						skipSkill: true,
 						requires: subcommand.requires,
 						optional: subcommand.optional,
 						schema: subcommand.schema,

package/src/cmd/project/create.ts

@@ -12,6 +12,7 @@ const ProjectCreateResponseSchema = z.object({
 	template: z.string().describe('Template used'),
 	installed: z.boolean().describe('Whether dependencies were installed'),
 	built: z.boolean().describe('Whether the project was built'),
+	domains: z.array(z.string()).optional().describe('Array of custom domains'),
 });
 
 export const createProjectSubcommand = createSubcommand({
@@ -40,6 +41,7 @@ export const createProjectSubcommand = createSubcommand({
 		options: z.object({
 			name: z.string().optional().describe('Project name'),
 			dir: z.string().optional().describe('Directory to create the project in'),
+			domains: z.array(z.string()).optional().describe('Array of custom domains'),
 			template: z.string().optional().describe('Template to use'),
 			templateDir: z
 				.string()
@@ -84,6 +86,7 @@ export const createProjectSubcommand = createSubcommand({
 		await runCreateFlow({
 			projectName: opts.name,
 			dir: opts.dir,
+			domains: opts.domains,
 			template: opts.template,
 			templateDir: opts.templateDir,
 			templateBranch: opts.templateBranch,

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

@@ -29,12 +29,14 @@ import {
 	filterAgentuitySdkKeys,
 	splitEnvAndSecrets,
 } from '../../env-util';
+import { promptForDNS } from '../../domain';
 
 type ResourcesTypes = z.infer<typeof Resources>;
 
 interface CreateFlowOptions {
 	projectName?: string;
 	dir?: string;
+	domains?: string[];
 	template?: string;
 	templateDir?: string;
 	templateBranch?: string;
@@ -63,6 +65,7 @@ export async function runCreateFlow(options: CreateFlowOptions): Promise<void> {
 		orgId: selectedOrgId,
 		region,
 		apiClient,
+		domains,
 	} = options;
 
 	// Fetch available templates
@@ -105,7 +108,8 @@ export async function runCreateFlow(options: CreateFlowOptions): Promise<void> {
 	if (!projectName && !skipPrompts) {
 		projectName = await prompt.text({
 			message: 'What is the name of your project?',
-			initial: 'My First Agent',
+			hint: 'The name must be unique for your organization',
+			initial: '',
 			validate: async (value: string) => {
 				if (!value || value.trim().length === 0) {
 					return 'Project name is required';
@@ -249,6 +253,7 @@ export async function runCreateFlow(options: CreateFlowOptions): Promise<void> {
 	}
 
 	const resourceConfig: ResourcesTypes = Resources.parse({});
+	let _domains = domains;
 
 	if (auth && apiClient && catalystClient && orgId && region && !skipPrompts) {
 		// Fetch resources for selected org and region using Catalyst API
@@ -265,8 +270,8 @@ export async function runCreateFlow(options: CreateFlowOptions): Promise<void> {
 		const db_action = await prompt.select({
 			message: 'Create SQL Database?',
 			options: [
-				{ value: 'Create New', label: 'Create a new (free)' },
 				{ value: 'Skip', label: 'Skip or Setup later' },
+				{ value: 'Create New', label: 'Create a new database' },
 				...resources.db.map((db) => ({
 					value: db.name,
 					label: `Use database: ${tui.tuiColors.primary(db.name)}`,
@@ -277,8 +282,8 @@ export async function runCreateFlow(options: CreateFlowOptions): Promise<void> {
 		const s3_action = await prompt.select({
 			message: 'Create Storage Bucket?',
 			options: [
-				{ value: 'Create New', label: 'Create a new (free)' },
 				{ value: 'Skip', label: 'Skip or Setup later' },
+				{ value: 'Create New', label: 'Create a new bucket' },
 				...resources.s3.map((bucket) => ({
 					value: bucket.bucket_name,
 					label: `Use bucket: ${tui.tuiColors.primary(bucket.bucket_name)}`,
@@ -286,6 +291,22 @@ export async function runCreateFlow(options: CreateFlowOptions): Promise<void> {
 			],
 		});
 
+		if (!domains?.length) {
+			const customDns = await prompt.text({
+				message: 'Setup custom DNS?',
+				hint: 'Enter a domain name or press Enter to skip',
+				validate: (val: string) =>
+					val === ''
+						? true
+						: /^(?=.{1,253}$)(?:[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+[A-Za-z]{2,63}$/.test(
+								val
+							),
+			});
+			if (customDns) {
+				_domains = [customDns];
+			}
+		}
+
 		const choices = { db_action, s3_action };
 		switch (choices.s3_action) {
 			case 'Create New': {
@@ -329,9 +350,9 @@ export async function runCreateFlow(options: CreateFlowOptions): Promise<void> {
 		}
 	}
 
-	if (auth && apiClient && orgId) {
-		let projectId: string | undefined;
+	let projectId: string | undefined;
 
+	if (auth && apiClient && orgId) {
 		const cloudRegion = region ?? process.env.AGENTUITY_REGION ?? 'usc';
 
 		const pkgJsonPath = resolve(dest, 'package.json');
@@ -355,6 +376,7 @@ export async function runCreateFlow(options: CreateFlowOptions): Promise<void> {
 					tags: tags.length > 0 ? tags : undefined,
 					orgId,
 					cloudRegion,
+					domains: _domains,
 				});
 				projectId = project.id;
 				return createProjectConfig(dest, {
@@ -363,6 +385,7 @@ export async function runCreateFlow(options: CreateFlowOptions): Promise<void> {
 					sdkKey: project.sdkKey,
 					deployment: {
 						resources: resourceConfig,
+						domains: _domains,
 					},
 					region: cloudRegion,
 				});
@@ -426,6 +449,15 @@ export async function runCreateFlow(options: CreateFlowOptions): Promise<void> {
 	}
 
 	playSound();
+
+	if (process.stdin.isTTY && !skipPrompts && _domains?.length && projectId) {
+		tui.newline();
+		const ok = await tui.confirm('Would you like to configure DNS now?', true);
+		if (ok) {
+			tui.newline();
+			await promptForDNS(projectId, _domains, config);
+		}
+	}
 }
 
 /**

package/src/cmd/setup/index.ts

@@ -9,6 +9,7 @@ export const command = createCommand({
 	description: 'Display first-run setup information (internal use)',
 	hidden: true,
 	skipUpgradeCheck: true,
+	skipSkill: true,
 	tags: ['read-only', 'fast'],
 	optional: { auth: true },
 	schema: {

package/src/cmd/upgrade/index.ts

@@ -6,9 +6,39 @@ import { ErrorCode, createError, exitWithError } from '../../errors';
 import * as tui from '../../tui';
 import { downloadWithProgress } from '../../download';
 import { $ } from 'bun';
-import { join } from 'node:path';
+import { join, dirname } from 'node:path';
 import { tmpdir } from 'node:os';
 import { randomUUID } from 'node:crypto';
+import { access, constants } from 'node:fs/promises';
+import { StructuredError } from '@agentuity/core';
+
+export const PermissionError = StructuredError('PermissionError')<{
+	binaryPath: string;
+	reason: string;
+}>();
+
+async function checkWritePermission(binaryPath: string): Promise<void> {
+	try {
+		await access(binaryPath, constants.W_OK);
+	} catch {
+		throw new PermissionError({
+			binaryPath,
+			reason: `Cannot write to ${binaryPath}. You may need to run with elevated permissions (e.g., sudo) or reinstall to a user-writable location.`,
+			message: `Permission denied: Cannot write to ${binaryPath}`,
+		});
+	}
+
+	const parentDir = dirname(binaryPath);
+	try {
+		await access(parentDir, constants.W_OK);
+	} catch {
+		throw new PermissionError({
+			binaryPath,
+			reason: `Cannot write to directory ${parentDir}. You may need to run with elevated permissions (e.g., sudo) or reinstall to a user-writable location.`,
+			message: `Permission denied: Cannot write to directory ${parentDir}`,
+		});
+	}
+}
 
 const UpgradeOptionsSchema = z.object({
 	force: z.boolean().optional().describe('Force upgrade even if version is the same'),
@@ -316,7 +346,7 @@ export const command = createCommand({
 				};
 			}
 
-			// Confirm upgrade
+			// Show version info
 			if (!force) {
 				tui.info(`Current version: ${tui.muted(normalizedCurrent)}`);
 				tui.info(`Latest version:  ${tui.bold(normalizedLatest)}`);
@@ -328,7 +358,43 @@ export const command = createCommand({
 				}
 				tui.success(`Release notes:   ${tui.link(getReleaseUrl(latestVersion))}`);
 				tui.newline();
+			}
 
+			// Check write permissions before prompting - fail early with helpful message
+			try {
+				await checkWritePermission(currentBinaryPath);
+			} catch (error) {
+				if (error instanceof PermissionError) {
+					tui.error('Unable to upgrade: permission denied');
+					tui.newline();
+					tui.warning(`The CLI binary at ${tui.bold(error.binaryPath)} is not writable.`);
+					tui.newline();
+					if (process.env.AGENTUITY_RUNTIME) {
+						console.log('You cannot self-upgrade the agentuity cli in the cloud runtime.');
+						console.log('The runtime will automatically update the cli and other software');
+						console.log('within a day or so. If you need assistance, please contact us');
+						console.log('at support@agentuity.com.');
+					} else {
+						console.log('To fix this, you can either:');
+						console.log(
+							`  1. Run with elevated permissions: ${tui.muted('sudo agentuity upgrade')}`
+						);
+						console.log(`  2. Reinstall to a user-writable location`);
+					}
+					tui.newline();
+					exitWithError(
+						createError(ErrorCode.PERMISSION_DENIED, 'Upgrade failed: permission denied', {
+							path: error.binaryPath,
+						}),
+						logger,
+						options.errorFormat
+					);
+				}
+				throw error;
+			}
+
+			// Confirm upgrade
+			if (!force) {
 				const shouldUpgrade = await tui.confirm('Do you want to upgrade?', true);
 
 				if (!shouldUpgrade) {
@@ -383,13 +449,11 @@ export const command = createCommand({
 				message,
 			};
 		} catch (error) {
-			// Parse validation errors to extract stdout/stderr if present
 			let errorDetails: Record<string, unknown> = {
 				error: error instanceof Error ? error.message : 'Unknown error',
 			};
 
 			if (error instanceof Error && error.message.includes('Binary validation failed')) {
-				// Extract stdout/stderr from validation error
 				const match = error.message.match(
 					/Failed with exit code (\d+)\n(stdout: .+\n)?(stderr: .+)?/s
 				);

package/src/config.ts

@@ -364,6 +364,15 @@ export async function getAuth(): Promise<AuthData | null> {
 		};
 	}
 
+	// Priority 1a: Allow automated login from environment variables (this is set in deployment)
+	if (process.env.AGENTUITY_API_KEY) {
+		return {
+			apiKey: process.env.AGENTUITY_API_KEY,
+			userId: '',
+			expires: new Date(Date.now() + 30 * 60_000),
+		};
+	}
+
 	// Priority 2: On macOS, try to read from Keychain
 	if (isMacOS()) {
 		try {

package/src/domain.ts

@@ -0,0 +1,273 @@
+import type { Config } from './types';
+import { StructuredError } from '@agentuity/core';
+import * as tui from './tui';
+
+interface BaseDNSResult {
+	domain: string;
+	target: string;
+	recordType: string;
+}
+
+interface DNSSuccess extends BaseDNSResult {
+	success: true;
+}
+
+interface DNSPending extends BaseDNSResult {
+	success: true;
+	pending: true;
+}
+
+interface DNSMissing extends BaseDNSResult {
+	success: false;
+	pending: false;
+}
+
+interface DNSError extends BaseDNSResult {
+	success: false;
+	error: string;
+}
+
+interface DNSMisconfigured extends BaseDNSResult {
+	success: false;
+	misconfigured: string;
+}
+
+export type DNSResult = DNSSuccess | DNSPending | DNSMissing | DNSError | DNSMisconfigured;
+export type DNSFailed = DNSPending | DNSMissing | DNSError | DNSMisconfigured;
+
+export function isMisconfigured(x: DNSResult): x is DNSMisconfigured {
+	return 'misconfigured' in x && !!x.misconfigured;
+}
+
+export function isMissing(x: DNSResult): x is DNSMissing {
+	return 'pending' in x && x.pending === false && 'success' in x && x.success === false;
+}
+
+export function isError(x: DNSResult): x is DNSError {
+	return 'error' in x && !!x.error;
+}
+
+export function isPending(x: DNSResult): x is DNSPending {
+	return 'pending' in x && x.pending === true && x.success === true;
+}
+
+export function isSuccess(x: DNSResult): x is DNSSuccess {
+	return x.success == true && !('pending' in x) && !('error' in x) && !('misconfigured' in x);
+}
+
+const timeoutMs = 5000;
+
+const DNSTimeoutError = StructuredError(
+	'DNSTimeoutError',
+	`DNS lookup timed out after ${timeoutMs}ms`
+);
+
+interface CFRecord {
+	Answer?: {
+		data: string;
+	}[];
+}
+
+async function fetchDNSRecord(name: string, type: string): Promise<string | null> {
+	const params = new URLSearchParams();
+	params.set('name', name);
+	params.set('type', type);
+	const res = await fetch(`https://cloudflare-dns.com/dns-query?${params.toString()}`, {
+		headers: {
+			Accept: 'application/dns-json',
+		},
+	});
+	if (res.ok) {
+		const result = (await res.json()) as CFRecord;
+		if (result?.Answer?.length) {
+			return result.Answer[0].data.replace(/\.$/, ''); // DNS records end with . so we remove that
+		}
+	}
+	return null;
+}
+
+const LOCAL_DNS = 'agentuity.io';
+const PRODUCTION_DNS = 'agentuity.run';
+
+/**
+ * This function will check for each of the custom domains and make sure they are correctly
+ * configured in DNS
+ *
+ * @param projectId the project id
+ * @param config Config
+ * @param domains array of domains to check
+ * @returns
+ */
+export async function checkCustomDomainForDNS(
+	projectId: string,
+	domains: string[],
+	config?: Config | null
+): Promise<DNSResult[]> {
+	const suffix = config?.overrides?.api_url?.includes('agentuity.io') ? LOCAL_DNS : PRODUCTION_DNS;
+	const id = Bun.hash.xxHash64(projectId).toString(16);
+	const proxy = `p${id}.${suffix}`;
+
+	return Promise.all(
+		domains.map(async (domain) => {
+			try {
+				let timeoutId: Timer | undefined;
+
+				const timeoutPromise = new Promise<never>((_, reject) => {
+					timeoutId = setTimeout(() => {
+						reject(new DNSTimeoutError());
+					}, timeoutMs);
+				});
+
+				const result = await Promise.race([
+					fetchDNSRecord(domain, 'CNAME'),
+					timeoutPromise,
+				]).finally(() => {
+					if (timeoutId) clearTimeout(timeoutId);
+				});
+
+				if (result) {
+					if (result === proxy) {
+						return {
+							domain,
+							target: proxy,
+							recordType: 'CNAME',
+							success: true,
+						} as DNSSuccess;
+					}
+					return {
+						domain,
+						target: proxy,
+						recordType: 'CNAME',
+						success: false,
+						misconfigured: `CNAME record is ${result}`,
+					} as DNSMisconfigured;
+				}
+			} catch (ex) {
+				const _ex = ex as { code: string; message?: string };
+				if (_ex.message?.includes('timed out')) {
+					return {
+						domain,
+						target: proxy,
+						recordType: 'CNAME',
+						success: false,
+						error: `DNS lookup timed out after 5 seconds. Please check your DNS configuration.`,
+					} as DNSError;
+				}
+				if (_ex.code !== 'ENOTFOUND') {
+					const errMsg =
+						ex instanceof Error
+							? ex.message
+							: typeof ex === 'string'
+								? ex
+								: JSON.stringify(ex);
+					return {
+						domain,
+						target: proxy,
+						recordType: 'CNAME',
+						success: false,
+						error: errMsg,
+					} as DNSError;
+				}
+			}
+			return {
+				domain,
+				success: false,
+				target: proxy,
+				recordType: 'CNAME',
+				pending: false,
+			} as DNSMissing;
+		})
+	);
+}
+
+export async function promptForDNS(
+	projectId: string,
+	domains: string[],
+	config?: Config,
+	resumeFn?: () => () => void
+) {
+	let paused = false;
+	let resume: (() => void) | undefined;
+	for (;;) {
+		const result = await checkCustomDomainForDNS(projectId, domains, config);
+		const failed = result.filter((x): x is DNSFailed => !isSuccess(x));
+		if (failed.length) {
+			const records: {
+				domain: string;
+				type: string;
+				target: string;
+				status: string;
+			}[] = [];
+			result.forEach((r) => {
+				if (isSuccess(r)) {
+					records.push({
+						domain: r.domain,
+						type: r.recordType,
+						target: r.target,
+						status: tui.colorSuccess(`${tui.ICONS.success} Configured`),
+					});
+				}
+			});
+			if (!paused) {
+				resume = resumeFn?.();
+				paused = true;
+			}
+			tui.error(
+				`You have ${tui.plural(failed.length, 'a ', '')}DNS configuration ${tui.plural(failed.length, 'issue', 'issues')} that must be resolved before deploying:`
+			);
+			for (const r of failed) {
+				if (isError(r)) {
+					resume?.();
+					throw new Error(r.error);
+				} else if (isMisconfigured(r)) {
+					records.push({
+						domain: r.domain,
+						type: r.recordType,
+						target: r.target,
+						status: tui.colorWarning(`${tui.ICONS.error} ${r.misconfigured}`),
+					});
+				} else if (isPending(r)) {
+					records.push({
+						domain: r.domain,
+						type: r.recordType,
+						target: r.target,
+						status: tui.colorWarning('⌛️ Pending'),
+					});
+				} else if (isMissing(r)) {
+					records.push({
+						domain: r.domain,
+						type: r.recordType,
+						target: r.target,
+						status: tui.colorError(`${tui.ICONS.error} Missing`),
+					});
+				}
+			}
+
+			let linesShown = 2; // header + footer
+			for (const record of records) {
+				console.log();
+				console.log(`${tui.colorInfo('Domain:')}  ${tui.colorPrimary(record.domain)}`);
+				console.log(`${tui.colorInfo('Type:')}    ${tui.colorPrimary(record.type)}`);
+				console.log(`${tui.colorInfo('Target:')}  ${tui.colorPrimary(record.target)}`);
+				console.log(`${tui.colorInfo('Status:')}  ${tui.colorPrimary(record.status)}`);
+				console.log();
+				linesShown += 6;
+			}
+
+			// await tui.waitForAnyKey('Press any key to check again or ctrl+c to cancel...');
+			await tui.spinner({
+				message: 'Checking again in 5s...',
+				clearOnSuccess: true,
+				callback: () => {
+					return Bun.sleep(5000);
+				},
+			});
+			tui.clearLastLines(linesShown);
+			linesShown = 0;
+			continue;
+		}
+		tui.clearLastLines(1);
+		resume?.();
+		break;
+	}
+}

package/src/index.ts

@@ -75,11 +75,6 @@ export { showBanner } from './banner';
 export { discoverCommands } from './cmd';
 export { detectColorScheme } from './terminal';
 export { getCommandPrefix, getCommand } from './command-prefix';
-export {
-	bootstrapRuntimeEnv,
-	type RuntimeBootstrapOptions,
-	type RuntimeBootstrapResult,
-} from './runtime-bootstrap';
 export * as tui from './tui';
 export {
 	createRepl,

package/src/runtime-bootstrap.md

@@ -43,7 +43,7 @@ Call `bootstrapRuntimeEnv()` at the top of your `app.ts` **before** `createApp()
 
 ```ts
 import { createApp } from '@agentuity/runtime';
-import { bootstrapRuntimeEnv } from '@agentuity/cli';
+import { bootstrapRuntimeEnv } from '@agentuity/runtime';
 
 // Bootstrap runtime environment based on active profile
 await bootstrapRuntimeEnv();

package/src/schema-generator.ts

@@ -48,6 +48,8 @@ export interface SchemaCommand {
 	prerequisites?: string[];
 	pagination?: SchemaPagination;
 	tags?: string[];
+	skipSkill?: boolean;
+	toplevel?: boolean;
 	subcommands?: SchemaCommand[];
 	requires?: {
 		auth?: boolean;
@@ -121,6 +123,13 @@ function extractCommandSchema(def: CommandDefinition): SchemaCommand {
 		schema.tags = (def as any).tags;
 	}
 
+	// Extract skipSkill
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+	if ((def as any).skipSkill !== undefined) {
+		// eslint-disable-next-line @typescript-eslint/no-explicit-any
+		schema.skipSkill = (def as any).skipSkill;
+	}
+
 	// Extract requires/optional
 	// eslint-disable-next-line @typescript-eslint/no-explicit-any
 	const d = def as any;
@@ -202,6 +211,20 @@ function extractSubcommandSchema(def: SubcommandDefinition): SchemaCommand {
 		schema.tags = (def as any).tags;
 	}
 
+	// Extract skipSkill
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+	if ((def as any).skipSkill !== undefined) {
+		// eslint-disable-next-line @typescript-eslint/no-explicit-any
+		schema.skipSkill = (def as any).skipSkill;
+	}
+
+	// Extract toplevel
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+	if ((def as any).toplevel !== undefined) {
+		// eslint-disable-next-line @typescript-eslint/no-explicit-any
+		schema.toplevel = (def as any).toplevel;
+	}
+
 	// Extract requires/optional
 	// eslint-disable-next-line @typescript-eslint/no-explicit-any
 	const d = def as any;