@agentuity/cli 1.0.31 → 1.0.33

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

@@ -1,44 +1,45 @@
-import { basename, resolve } from 'node:path';
 import { existsSync, readdirSync, rmSync, statSync } from 'node:fs';
-import { cwd } from 'node:process';
 import { homedir } from 'node:os';
+import { basename, resolve } from 'node:path';
+import { cwd } from 'node:process';
+import type { Logger } from '@agentuity/core';
 import {
-	projectCreate,
-	projectExists,
+	createResources,
+	getServiceUrls,
 	listResources,
+	projectCreate,
 	projectEnvUpdate,
-	getServiceUrls,
+	projectExists,
 	APIClient as ServerAPIClient,
-	createResources,
-	validateDatabaseName,
 	validateBucketName,
+	validateDatabaseName,
 } from '@agentuity/server';
-import type { Logger } from '@agentuity/core';
-import * as tui from '../../tui';
-import { createPrompt, note } from '../../tui';
-import { playSound } from '../../sound';
-import { fetchTemplates, type TemplateInfo } from './templates';
-import { downloadTemplate, setupProject, initGitRepo } from './download';
-import { type AuthData, type Config } from '../../types';
-import { ErrorCode } from '../../errors';
 import type { APIClient } from '../../api';
 import { createProjectConfig } from '../../config';
+import { promptForDNS } from '../../domain';
 import {
+	addResourceEnvVars,
+	type EnvVars,
+	filterAgentuitySdkKeys,
 	findExistingEnvFile,
 	readEnvFile,
-	filterAgentuitySdkKeys,
 	splitEnvAndSecrets,
-	addResourceEnvVars,
-	type EnvVars,
 } from '../../env-util';
-import { promptForDNS } from '../../domain';
+import { ErrorCode } from '../../errors';
+import { playSound } from '../../sound';
+import * as tui from '../../tui';
+import { createPrompt, note } from '../../tui';
+import type { AuthData, Config } from '../../types';
+import { getGithubBotIdentity } from '../git/api';
 import {
 	ensureAuthDependencies,
-	runAuthMigrations,
 	generateAuthFileContent,
-	printIntegrationExamples,
 	generateAuthSchemaSql,
+	printIntegrationExamples,
+	runAuthMigrations,
 } from './auth/shared';
+import { downloadTemplate, initGitRepo, setupProject } from './download';
+import { fetchTemplates, type TemplateInfo } from './templates';
 
 interface CreateFlowOptions {
 	projectName?: string;
@@ -655,6 +656,7 @@ export async function runCreateFlow(options: CreateFlowOptions): Promise<CreateF
 				region,
 				databaseName: authDatabaseName,
 				sql,
+				config,
 			});
 		}
 	}
@@ -755,8 +757,22 @@ export async function runCreateFlow(options: CreateFlowOptions): Promise<CreateF
 		}
 	}
 
+	// Fetch GitHub App bot identity for commit authorship (if authenticated)
+	let botAuthor: { name: string; email: string } | undefined;
+	if (apiClient) {
+		try {
+			botAuthor = await getGithubBotIdentity(apiClient);
+		} catch {
+			// Non-fatal: fall back to generic Agentuity author
+		}
+	}
+
 	// Initialize git repository after all files are generated
-	await initGitRepo(dest);
+	await initGitRepo(dest, {
+		projectName,
+		source: `template: ${selectedTemplate.name}`,
+		author: botAuthor,
+	});
 
 	// Show completion message
 	if (isInteractive) {

package/src/config.ts

@@ -1,25 +1,29 @@
-import { z } from 'zod';
 import { existsSync, mkdirSync } from 'node:fs';
-import { StructuredError, type Logger } from '@agentuity/core';
-import { BuildMetadataSchema, type BuildMetadata, getServiceUrls } from '@agentuity/server';
-import { APIClient as ServerAPIClient } from '@agentuity/server';
-import { YAML } from 'bun';
-import { join, extname, basename, resolve, normalize } from 'node:path';
+import { chmod, mkdir, readdir, readFile, writeFile } from 'node:fs/promises';
 import { homedir } from 'node:os';
-import { mkdir, readdir, readFile, writeFile, chmod } from 'node:fs/promises';
+import { basename, extname, join, normalize, resolve } from 'node:path';
+import { type Logger, StructuredError } from '@agentuity/core';
+import {
+	type BuildMetadata,
+	BuildMetadataSchema,
+	getServiceUrls,
+	APIClient as ServerAPIClient,
+} from '@agentuity/server';
+import { YAML } from 'bun';
 import JSON5 from 'json5';
-import type { Config, Profile, AuthData } from './types';
-import { ConfigSchema, ProjectSchema } from './types';
-import * as tui from './tui';
+import { z } from 'zod';
+import { clearProfileCache } from './cache';
 import { getCatalystUrl } from './catalyst';
+import { readEnvFile, writeEnvFile } from './env-util';
 import {
+	deleteAuthFromKeychain,
+	getAuthFromKeychain,
 	isMacOS,
 	saveAuthToKeychain,
-	getAuthFromKeychain,
-	deleteAuthFromKeychain,
 } from './keychain';
-import { clearProfileCache } from './cache';
-import { readEnvFile, writeEnvFile } from './env-util';
+import * as tui from './tui';
+import type { AuthData, Config, Profile } from './types';
+import { ConfigSchema, ProjectSchema } from './types';
 
 export const defaultProfileName = 'production';
 
@@ -768,16 +772,17 @@ export async function loadProjectSDKKey(
 			logger.trace(`[SDK_KEY] File does not exist: ${fn}`);
 		}
 	}
-	logger.trace(`[SDK_KEY] AGENTUITY_SDK_KEY not found in any file`);
+	logger.trace('[SDK_KEY] AGENTUITY_SDK_KEY not found in any file');
 }
 
 export function getCatalystAPIClient(
 	logger: Logger,
 	auth: AuthData,
 	region: string,
-	orgId?: string
+	orgId?: string,
+	config?: Config | null
 ) {
-	const catalystUrl = getCatalystUrl(region);
+	const catalystUrl = getCatalystUrl(region, config?.overrides);
 	const headers: Record<string, string> = {};
 	if (orgId) {
 		headers['x-agentuity-orgid'] = orgId;
@@ -857,7 +862,7 @@ export async function getGlobalCatalystAPIClient(
 	config?: Config | null
 ) {
 	const region = await getDefaultRegion(profileName, config);
-	return getCatalystAPIClient(logger, auth, region, orgId);
+	return getCatalystAPIClient(logger, auth, region, orgId, config);
 }
 
 export function getIONHost(config: Config | null, region: string) {

package/src/domain.ts

@@ -54,7 +54,7 @@ export function isPending(x: DNSResult): x is DNSPending {
 }
 
 export function isSuccess(x: DNSResult): x is DNSSuccess {
-	return x.success == true && !('pending' in x) && !('error' in x) && !('misconfigured' in x);
+	return x.success === true && !('pending' in x) && !('error' in x) && !('misconfigured' in x);
 }
 
 const timeoutMs = 5000;
@@ -195,8 +195,8 @@ export async function checkCustomDomainForDNS(
 					if (timeoutId) clearTimeout(timeoutId);
 				});
 
-			if (result) {
-				if (result === proxy) {
+				if (result) {
+					if (result === proxy) {
 						// DNS is correct — verify TLS certificate (also triggers Let's Encrypt provisioning)
 						const tlsValid = await checkTLSCertificate(domain);
 						if (tlsValid) {

package/src/schema-generator.ts

@@ -290,7 +290,7 @@ function extractSubcommandSchema(def: SubcommandDefinition): SchemaCommand {
  * Generate JSON schema for the entire CLI
  */
 export function generateCLISchema(
-	program: Command,
+	_program: Command,
 	commands: CommandDefinition[],
 	version: string
 ): CLISchema {

package/src/schema-parser.ts

@@ -113,6 +113,34 @@ function getShape(schema: ZodType): Record<string, unknown> {
 		return { ...leftShape, ...rightShape };
 	}
 
+	if (typeId === 'ZodTuple' || typeId === 'tuple') {
+		// eslint-disable-next-line @typescript-eslint/no-explicit-any
+		const items = (unwrapped as any)._def?.items as unknown[];
+		if (Array.isArray(items)) {
+			const result: Record<string, unknown> = {};
+			for (let i = 0; i < items.length; i++) {
+				const item = items[i] as ZodTypeInternal;
+				// Try to extract a name from the description — check the item directly (Zod 4),
+				// the _def (Zod 3), and the unwrapped inner schema
+				const desc =
+					(item as unknown as { description?: string })?.description ||
+					item?._def?.description ||
+					(unwrapSchema(item) as ZodTypeInternal)?._def?.description ||
+					(unwrapSchema(item) as unknown as { description?: string })?.description;
+				let name = `arg${i}`;
+				if (desc) {
+					// Slugify: lowercase, replace non-alphanumeric with dashes, trim
+					name = desc
+						.toLowerCase()
+						.replace(/[^a-z0-9]+/g, '-')
+						.replace(/^-|-$/g, '');
+				}
+				result[name] = item;
+			}
+			return result;
+		}
+	}
+
 	return {};
 }
 
@@ -371,11 +399,26 @@ export function buildValidationInput(
 	const result = { args: {} as Record<string, unknown>, options: {} as Record<string, unknown> };
 
 	if (schemas.args) {
-		const parsed = parseArgsSchema(schemas.args);
-		for (let i = 0; i < parsed.names.length; i++) {
-			const name = parsed.names[i];
-			if (name !== undefined) {
-				result.args[name] = rawArgs[i];
+		// Check if the schema is a tuple — tuples need array input, not object
+		const unwrapped = unwrapSchema(schemas.args) as ZodTypeInternal;
+		const typeId = unwrapped?._def?.typeName || unwrapped?._def?.type;
+		if (typeId === 'ZodTuple' || typeId === 'tuple') {
+			// Tuple schemas — map each item to a named key from the schema
+			// (rawArgs may include trailing Commander.js options object)
+			const parsed = parseArgsSchema(schemas.args);
+			for (let i = 0; i < parsed.names.length; i++) {
+				const name = parsed.names[i];
+				if (name !== undefined) {
+					result.args[name] = rawArgs[i];
+				}
+			}
+		} else {
+			const parsed = parseArgsSchema(schemas.args);
+			for (let i = 0; i < parsed.names.length; i++) {
+				const name = parsed.names[i];
+				if (name !== undefined) {
+					result.args[name] = rawArgs[i];
+				}
 			}
 		}
 	}
@@ -421,7 +464,7 @@ export async function buildValidationInputAsync(
 	if (schemas.options && !options?.usesStdin) {
 		// Use getShape() instead of parseOptionsSchema() to avoid re-evaluating function defaults
 		const shape = getShape(schemas.options);
-		const hasConfirmOption = Object.prototype.hasOwnProperty.call(shape, 'confirm');
+		const hasConfirmOption = Object.hasOwn(shape, 'confirm');
 		const confirmValue = result.options.confirm;
 
 		if (hasConfirmOption && confirmValue === undefined) {

package/src/terminal.ts

@@ -31,9 +31,8 @@ export async function detectColorScheme(): Promise<ColorScheme> {
 						`[DEBUG] OSC 11 response: rgb(${bgColor.r},${bgColor.g},${bgColor.b}), luminance: ${luminance.toFixed(2)}, scheme: ${scheme}`
 					);
 				return scheme;
-			} else {
-				if (debug) console.log('[DEBUG] OSC 11 query timed out or no response');
 			}
+			if (debug) console.log('[DEBUG] OSC 11 query timed out or no response');
 		} catch (error) {
 			if (debug) console.log('[DEBUG] OSC 11 query failed:', error);
 		}
@@ -44,8 +43,8 @@ export async function detectColorScheme(): Promise<ColorScheme> {
 		// COLORFGBG format is "foreground;background"
 		// This is unreliable but better than nothing
 		const parts = process.env.COLORFGBG.split(';');
-		const fg = parseInt(parts[0] || '7', 10);
-		const bg = parseInt(parts[1] || '0', 10);
+		const fg = Number.parseInt(parts[0] || '7', 10);
+		const bg = Number.parseInt(parts[1] || '0', 10);
 
 		// Heuristic: if background is 0 (black) and foreground is light (>=7), it's likely dark mode
 		// if background is light (>=7) and foreground is dark (<7), it's likely light mode
@@ -88,7 +87,6 @@ async function queryTerminalBackground(): Promise<RGBColor | null> {
 			// Pattern 1: ESC ] 11 ; rgb:RRRR/GGGG/BBBB ESC \ (xterm with ESC \ terminator)
 			// Pattern 2: ESC ] 11 ; rgb:RRRR/GGGG/BBBB BEL (xterm with BEL terminator)
 			// The color values can be 8-bit (RR), 12-bit (RRR), or 16-bit (RRRR)
-			// biome-ignore lint/suspicious/noControlCharactersInRegex: Control characters needed for ANSI escape sequences
 			const match = response.match(
 				// eslint-disable-next-line no-control-regex
 				/\x1b\]11;rgb:([0-9a-f]+)\/([0-9a-f]+)\/([0-9a-f]+)(?:\x1b\\|\x07)/i
@@ -103,14 +101,14 @@ async function queryTerminalBackground(): Promise<RGBColor | null> {
 					if (!hex) return 0;
 					if (hex.length === 4) {
 						// 16-bit: RRRR -> take first 2 chars
-						return parseInt(hex.slice(0, 2), 16);
-					} else if (hex.length === 3) {
+						return Number.parseInt(hex.slice(0, 2), 16);
+					}
+					if (hex.length === 3) {
 						// 12-bit: RRR -> take first 2 chars
-						return parseInt(hex.slice(0, 2), 16);
-					} else {
-						// 8-bit: RR
-						return parseInt(hex, 16);
+						return Number.parseInt(hex.slice(0, 2), 16);
 					}
+					// 8-bit: RR
+					return Number.parseInt(hex, 16);
 				};
 
 				const r = parseColorValue(match[1]);
@@ -145,9 +143,9 @@ function calculateLuminance(color: RGBColor): number {
 	const gsRGB = color.g / 255;
 	const bsRGB = color.b / 255;
 
-	const r = rsRGB <= 0.03928 ? rsRGB / 12.92 : Math.pow((rsRGB + 0.055) / 1.055, 2.4);
-	const g = gsRGB <= 0.03928 ? gsRGB / 12.92 : Math.pow((gsRGB + 0.055) / 1.055, 2.4);
-	const b = bsRGB <= 0.03928 ? bsRGB / 12.92 : Math.pow((bsRGB + 0.055) / 1.055, 2.4);
+	const r = rsRGB <= 0.03928 ? rsRGB / 12.92 : ((rsRGB + 0.055) / 1.055) ** 2.4;
+	const g = gsRGB <= 0.03928 ? gsRGB / 12.92 : ((gsRGB + 0.055) / 1.055) ** 2.4;
+	const b = bsRGB <= 0.03928 ? bsRGB / 12.92 : ((bsRGB + 0.055) / 1.055) ** 2.4;
 
 	return 0.2126 * r + 0.7152 * g + 0.0722 * b;
 }

package/src/tui.ts

@@ -130,7 +130,7 @@ export function getTerminalWidth(defaultWidth = 80): number {
 	}
 	if (process.env.COLUMNS) {
 		const cols = parseInt(process.env.COLUMNS, 10);
-		if (!isNaN(cols) && cols > 0) {
+		if (!Number.isNaN(cols) && cols > 0) {
 			return cols;
 		}
 	}

package/src/types.ts

@@ -716,6 +716,50 @@ export type SubcommandDefinition =
 			optional?: Optional & { auth?: never };
 	  });
 
+const TemplateResourceSchema = zod.object({
+	type: zod.enum(['database', 'queue']).describe('the type of resource required'),
+	envVar: zod
+		.string()
+		.describe('the environment variable that holds the resource connection info'),
+	description: zod.string().optional().describe('human-readable description of the resource'),
+	defaultName: zod
+		.string()
+		.optional()
+		.describe('suggested default name when provisioning this resource'),
+	queueType: zod
+		.enum(['worker', 'pubsub'])
+		.optional()
+		.describe('queue type — required when type is "queue"'),
+});
+
+const TemplateEnvSchema = zod.object({
+	key: zod.string().describe('the environment variable name'),
+	required: zod.boolean().describe('whether this env var is required'),
+	description: zod.string().optional().describe('human-readable description'),
+	secret: zod.boolean().optional().describe('whether this env var is a secret'),
+	defaultValue: zod.string().optional().describe('default or example value'),
+});
+
+const TemplateSchema = zod.object({
+	source: zod
+		.string()
+		.optional()
+		.describe('where the template came from (e.g. github.com/owner/repo)'),
+	requirements: zod
+		.object({
+			resources: zod
+				.array(TemplateResourceSchema)
+				.optional()
+				.describe('platform resources the project needs'),
+			env: zod
+				.array(TemplateEnvSchema)
+				.optional()
+				.describe('environment variables the project needs'),
+		})
+		.optional()
+		.describe('what the template requires to run'),
+});
+
 export const ProjectSchema = zod.object({
 	projectId: zod.string().describe('the project id'),
 	orgId: zod.string().describe('the organization id'),
@@ -726,6 +770,7 @@ export const ProjectSchema = zod.object({
 		.boolean()
 		.optional()
 		.describe('whether to skip the git integration setup prompt during deploy'),
+	template: TemplateSchema.optional().describe('template metadata and requirements'),
 });
 
 export const BuildMetadataSchema = ServerBuildMetadataSchema;

package/src/utils/date.ts

@@ -19,7 +19,7 @@ export function parseExpiresAt(input: string): string {
 	if (input.includes('T') || input.includes('-')) {
 		// Validate it's a valid date
 		const date = new Date(input);
-		if (isNaN(date.getTime())) {
+		if (Number.isNaN(date.getTime())) {
 			throw new InvalidDateFormatError({ input, message: `Invalid date format: ${input}` });
 		}
 		return date.toISOString();