@agentuity/cli 1.0.32 → 1.0.34

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/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];
+				}
 			}
 		}
 	}

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;