@agentuity/cli 1.0.31 → 1.0.33

package/src/cmd/cloud/task/util.ts

@@ -1,10 +1,10 @@
-import { TaskStorageService, type Logger } from '@agentuity/core';
+import { type Logger, TaskStorageService } from '@agentuity/core';
 import { createServerFetchAdapter } from '@agentuity/server';
-import type { AuthData, Config, GlobalOptions } from '../../../types';
-import { getCatalystUrl } from '../../../catalyst';
 import { setResourceInfo } from '../../../cache';
+import { getCatalystUrl } from '../../../catalyst';
 import { defaultProfileName, getDefaultRegion } from '../../../config';
 import * as tui from '../../../tui';
+import type { AuthData, Config, GlobalOptions } from '../../../types';
 
 export interface TaskContext {
 	logger: Logger;
@@ -32,7 +32,7 @@ export async function createStorageAdapter(ctx: TaskContext) {
 
 	// Task tenant DB is not regional — any Catalyst can serve the request.
 	const region = await getDefaultRegion(ctx.config?.name ?? defaultProfileName, ctx.config);
-	const baseUrl = getCatalystUrl(region);
+	const baseUrl = getCatalystUrl(region, ctx.config?.overrides);
 	return new TaskStorageService(baseUrl, adapter);
 }
 

package/src/cmd/cloud/thread/delete.ts

@@ -1,10 +1,10 @@
+import { APIError, threadDelete } from '@agentuity/server';
 import { z } from 'zod';
-import { createSubcommand } from '../../../types';
-import * as tui from '../../../tui';
-import { threadDelete, APIError } from '@agentuity/server';
 import { getCommand } from '../../../command-prefix';
-import { ErrorCode } from '../../../errors';
 import { getGlobalCatalystAPIClient } from '../../../config';
+import { ErrorCode } from '../../../errors';
+import * as tui from '../../../tui';
+import { createSubcommand } from '../../../types';
 
 export const deleteSubcommand = createSubcommand({
 	name: 'delete',
@@ -25,7 +25,13 @@ export const deleteSubcommand = createSubcommand({
 	},
 	async handler(ctx) {
 		const { logger, auth, args, config } = ctx;
-		const catalystClient = await getGlobalCatalystAPIClient(logger, auth, config?.name);
+		const catalystClient = await getGlobalCatalystAPIClient(
+			logger,
+			auth,
+			config?.name,
+			undefined,
+			config
+		);
 
 		try {
 			await threadDelete(catalystClient, { id: args.thread_id });

package/src/cmd/cloud/thread/get.ts

@@ -1,10 +1,10 @@
+import { APIError, threadGet } from '@agentuity/server';
 import { z } from 'zod';
-import { createSubcommand } from '../../../types';
-import * as tui from '../../../tui';
-import { threadGet, APIError } from '@agentuity/server';
 import { getCommand } from '../../../command-prefix';
-import { ErrorCode } from '../../../errors';
 import { getGlobalCatalystAPIClient } from '../../../config';
+import { ErrorCode } from '../../../errors';
+import * as tui from '../../../tui';
+import { createSubcommand } from '../../../types';
 
 const ThreadGetResponseSchema = z.object({
 	id: z.string().describe('Thread ID'),
@@ -38,7 +38,13 @@ export const getSubcommand = createSubcommand({
 	},
 	async handler(ctx) {
 		const { logger, auth, args, options, config } = ctx;
-		const catalystClient = await getGlobalCatalystAPIClient(logger, auth, config?.name);
+		const catalystClient = await getGlobalCatalystAPIClient(
+			logger,
+			auth,
+			config?.name,
+			undefined,
+			config
+		);
 
 		try {
 			const thread = await threadGet(catalystClient, { id: args.thread_id });

package/src/cmd/cloud/thread/list.ts

@@ -1,10 +1,10 @@
+import { type Thread, threadList } from '@agentuity/server';
 import { z } from 'zod';
-import { createSubcommand } from '../../../types';
-import * as tui from '../../../tui';
-import { threadList, type Thread } from '@agentuity/server';
 import { getCommand } from '../../../command-prefix';
-import { ErrorCode } from '../../../errors';
 import { getGlobalCatalystAPIClient } from '../../../config';
+import { ErrorCode } from '../../../errors';
+import * as tui from '../../../tui';
+import { createSubcommand } from '../../../types';
 
 const ThreadListResponseSchema = z.array(
 	z.object({
@@ -73,7 +73,13 @@ export const listSubcommand = createSubcommand({
 	},
 	async handler(ctx) {
 		const { logger, auth, project, opts, options, config } = ctx;
-		const catalystClient = await getGlobalCatalystAPIClient(logger, auth, config?.name);
+		const catalystClient = await getGlobalCatalystAPIClient(
+			logger,
+			auth,
+			config?.name,
+			undefined,
+			config
+		);
 
 		if (opts?.orgId && opts?.projectId) {
 			tui.fatal('--org-id and --project-id are mutually exclusive. Use one or the other.');

package/src/cmd/cloud/vector/util.ts

@@ -1,8 +1,8 @@
 import { type Logger, VectorStorageService } from '@agentuity/core';
 import { createServerFetchAdapter } from '@agentuity/server';
-import type { AuthData, Config, GlobalOptions, ProjectConfig } from '../../../types';
 import { getCatalystUrl } from '../../../catalyst';
 import * as tui from '../../../tui';
+import type { AuthData, Config, GlobalOptions, ProjectConfig } from '../../../types';
 
 export function createStorageAdapter(
 	ctx: {
@@ -36,6 +36,6 @@ export function createStorageAdapter(
 		ctx.logger
 	);
 
-	const baseUrl = getCatalystUrl(ctx.region);
+	const baseUrl = getCatalystUrl(ctx.region, ctx.config?.overrides);
 	return new VectorStorageService(baseUrl, adapter);
 }

package/src/cmd/cloud/webhook/util.ts

@@ -1,5 +1,5 @@
 import type { Logger } from '@agentuity/core';
-import { APIClient, type WebhookApiOptions } from '@agentuity/server';
+import type { APIClient, WebhookApiOptions } from '@agentuity/server';
 import { getGlobalCatalystAPIClient } from '../../../config';
 import type { AuthData, Config, GlobalOptions } from '../../../types';
 
@@ -21,7 +21,7 @@ export interface WebhookContext {
  * Uses the global Catalyst API client with user authentication.
  */
 export async function createWebhookAPIClient(ctx: WebhookContext): Promise<APIClient> {
-	return getGlobalCatalystAPIClient(ctx.logger, ctx.auth, ctx.config?.name);
+	return getGlobalCatalystAPIClient(ctx.logger, ctx.auth, ctx.config?.name, undefined, ctx.config);
 }
 
 /**

package/src/cmd/dev/dev-lock.ts

@@ -205,7 +205,7 @@ async function cleanupStaleLock(
  */
 async function ensureNoActiveDevForProject(
 	rootDir: string,
-	port: number,
+	_port: number,
 	logger: LoggerLike
 ): Promise<void> {
 	const lockPath = getLockPath(rootDir);
@@ -214,7 +214,7 @@ async function ensureNoActiveDevForProject(
 
 	const now = Date.now();
 	const createdAt = Date.parse(existing.createdAt || '');
-	const ageMs = isFinite(createdAt) ? now - createdAt : Infinity;
+	const ageMs = Number.isFinite(createdAt) ? now - createdAt : Infinity;
 
 	const mainAlive = pidExists(existing.mainPid);
 

package/src/cmd/dev/templates.ts

@@ -35,7 +35,6 @@ export default router;
 
 const invalidDirRegex = /[<>:"/\\|?*]/;
 
-// biome-ignore lint/suspicious/noControlCharactersInRegex: checking for invalid control characters in directory names
 const invalidControlChars = /[\u0000-\u001F]/;
 const reservedWindowsNames = /^(con|prn|aux|nul|com[1-9]|lpt[1-9])$/i;
 const invalidTrailing = /[. ]$/;

package/src/cmd/git/api.ts

@@ -315,3 +315,130 @@ export async function getProjectGithubStatus(
 
 	return resp.data;
 }
+
+// ─── GitHub Token ───
+
+const GithubTokenDataSchema = z.object({
+	token: z.string(),
+	username: z.string(),
+});
+
+export type GithubTokenResult = z.infer<typeof GithubTokenDataSchema>;
+
+const GithubTokenError = StructuredError(
+	'GithubTokenError',
+	'Failed to retrieve GitHub token from Agentuity'
+);
+
+export async function getGithubToken(apiClient: APIClient): Promise<GithubTokenResult> {
+	const resp = await apiClient.get('/cli/github/token', APIResponseSchema(GithubTokenDataSchema));
+
+	if (!resp.success || !resp.data) {
+		throw new GithubTokenError();
+	}
+
+	return resp.data;
+}
+
+const GithubRepoCheckDataSchema = z.object({
+	available: z.boolean(),
+	exists: z.boolean(),
+	error: z.string().optional(),
+});
+
+export type GithubRepoCheckResult = z.infer<typeof GithubRepoCheckDataSchema>;
+
+const GithubRepoCheckError = StructuredError(
+	'GithubRepoCheckError',
+	'Error checking GitHub repository availability'
+);
+
+export async function checkGithubRepo(
+	apiClient: APIClient,
+	params: { owner: string; name: string }
+): Promise<GithubRepoCheckResult> {
+	const resp = await apiClient.get(
+		`/cli/github/repo/check?owner=${encodeURIComponent(params.owner)}&name=${encodeURIComponent(params.name)}`,
+		APIResponseSchema(GithubRepoCheckDataSchema)
+	);
+
+	if (!resp.success || !resp.data) {
+		throw new GithubRepoCheckError();
+	}
+
+	return resp.data;
+}
+
+// Repo creation
+
+const GithubRepoCreateDataSchema = z.object({
+	url: z.string(),
+	cloneUrl: z.string(),
+	fullName: z.string(),
+	private: z.boolean(),
+	created: z.boolean(),
+});
+
+export interface GithubRepoCreateResult {
+	url: string;
+	cloneUrl: string;
+	fullName: string;
+	private: boolean;
+	created: boolean;
+}
+
+export interface GithubRepoCreateOptions {
+	name: string;
+	owner: string;
+	private: boolean;
+	description?: string;
+}
+
+const GithubRepoCreateError = StructuredError(
+	'GithubRepoCreateError',
+	'Error creating GitHub repository'
+);
+
+export async function createGithubRepo(
+	apiClient: APIClient,
+	params: GithubRepoCreateOptions
+): Promise<GithubRepoCreateResult> {
+	const resp = await apiClient.post(
+		'/cli/github/repo',
+		params,
+		APIResponseSchema(GithubRepoCreateDataSchema)
+	);
+
+	if (!resp.success || !resp.data) {
+		throw new GithubRepoCreateError();
+	}
+
+	return resp.data;
+}
+
+// ─── Bot Identity ───
+
+const GithubBotIdentityDataSchema = z.object({
+	name: z.string(),
+	email: z.string(),
+});
+
+export type GithubBotIdentity = z.infer<typeof GithubBotIdentityDataSchema>;
+
+const GithubBotIdentityError = StructuredError(
+	'GithubBotIdentityError',
+	'Error fetching GitHub App bot identity'
+);
+
+export async function getGithubBotIdentity(apiClient: APIClient): Promise<GithubBotIdentity> {
+	const resp = await apiClient.get(
+		'/cli/github/bot-identity',
+		APIResponseSchema(GithubBotIdentityDataSchema)
+	);
+
+	if (!resp.success || !resp.data) {
+		throw new GithubBotIdentityError();
+	}
+
+	return resp.data;
+}

package/src/cmd/project/add/database.ts

@@ -1,19 +1,19 @@
-import { z } from 'zod';
 import { listResources, projectEnvUpdate } from '@agentuity/server';
-import { createSubcommand } from '../../../types';
-import * as tui from '../../../tui';
-import { createPrompt } from '../../../tui';
-import { getCatalystAPIClient } from '../../../config';
+import { z } from 'zod';
 import { getCommand } from '../../../command-prefix';
-import { isDryRunMode, outputDryRun } from '../../../explain';
-import { ErrorCode } from '../../../errors';
+import { getCatalystAPIClient } from '../../../config';
 import {
 	addResourceEnvVars,
+	filterAgentuitySdkKeys,
 	findExistingEnvFile,
 	readEnvFile,
-	filterAgentuitySdkKeys,
 	splitEnvAndSecrets,
 } from '../../../env-util';
+import { ErrorCode } from '../../../errors';
+import { isDryRunMode, outputDryRun } from '../../../explain';
+import * as tui from '../../../tui';
+import { createPrompt } from '../../../tui';
+import { createSubcommand } from '../../../types';
 
 export const databaseSubcommand = createSubcommand({
 	name: 'database',
@@ -65,7 +65,7 @@ export const databaseSubcommand = createSubcommand({
 			};
 		}
 
-		const catalystClient = getCatalystAPIClient(logger, auth, region);
+		const catalystClient = getCatalystAPIClient(logger, auth, region, undefined, ctx.config);
 
 		const resources = await tui.spinner({
 			message: 'Fetching databases',

package/src/cmd/project/add/storage.ts

@@ -1,19 +1,19 @@
-import { z } from 'zod';
 import { listResources, projectEnvUpdate } from '@agentuity/server';
-import { createSubcommand } from '../../../types';
-import * as tui from '../../../tui';
-import { createPrompt } from '../../../tui';
-import { getCatalystAPIClient } from '../../../config';
+import { z } from 'zod';
 import { getCommand } from '../../../command-prefix';
-import { isDryRunMode, outputDryRun } from '../../../explain';
-import { ErrorCode } from '../../../errors';
+import { getCatalystAPIClient } from '../../../config';
 import {
 	addResourceEnvVars,
+	filterAgentuitySdkKeys,
 	findExistingEnvFile,
 	readEnvFile,
-	filterAgentuitySdkKeys,
 	splitEnvAndSecrets,
 } from '../../../env-util';
+import { ErrorCode } from '../../../errors';
+import { isDryRunMode, outputDryRun } from '../../../explain';
+import * as tui from '../../../tui';
+import { createPrompt } from '../../../tui';
+import { createSubcommand } from '../../../types';
 
 export const storageSubcommand = createSubcommand({
 	name: 'storage',
@@ -65,7 +65,7 @@ export const storageSubcommand = createSubcommand({
 			};
 		}
 
-		const catalystClient = getCatalystAPIClient(logger, auth, region);
+		const catalystClient = getCatalystAPIClient(logger, auth, region, undefined, ctx.config);
 
 		const resources = await tui.spinner({
 			message: 'Fetching storage buckets',

package/src/cmd/project/auth/init.ts

@@ -1,21 +1,21 @@
+import enquirer from 'enquirer';
+import * as fs from 'fs';
+import * as path from 'path';
 import { z } from 'zod';
-import { createSubcommand } from '../../../types';
-import * as tui from '../../../tui';
 import { getCommand } from '../../../command-prefix';
+import { readEnvFile, writeEnvFile } from '../../../env-util';
+import * as tui from '../../../tui';
+import { createSubcommand } from '../../../types';
 import {
-	selectOrCreateDatabase,
+	detectOrmSetup,
 	ensureAuthDependencies,
-	runAuthMigrations,
 	generateAuthFileContent,
-	printIntegrationExamples,
-	detectOrmSetup,
 	generateAuthSchemaSql,
 	getGeneratedSqlDir,
+	printIntegrationExamples,
+	runAuthMigrations,
+	selectOrCreateDatabase,
 } from './shared';
-import { readEnvFile, writeEnvFile } from '../../../env-util';
-import enquirer from 'enquirer';
-import * as fs from 'fs';
-import * as path from 'path';
 
 export const initSubcommand = createSubcommand({
 	name: 'init',
@@ -232,6 +232,7 @@ export const initSubcommand = createSubcommand({
 						region,
 						databaseName,
 						sql,
+						config,
 					});
 					migrationsRun = true;
 				}

package/src/cmd/project/auth/shared.ts

@@ -3,18 +3,16 @@
  */
 
 import * as path from 'node:path';
-import { listOrgResources, createResources, dbQuery } from '@agentuity/server';
-import * as tui from '../../../tui';
+import { createResources, dbQuery, listOrgResources } from '@agentuity/server';
+import enquirer from 'enquirer';
 import {
 	getCatalystAPIClient,
 	getGlobalCatalystAPIClient,
 	loadProjectConfig,
 	ProjectConfigNotFoundException,
 } from '../../../config';
-import type { Logger } from '../../../types';
-import type { AuthData } from '../../../types';
-import type { Config } from '../../../types';
-import enquirer from 'enquirer';
+import * as tui from '../../../tui';
+import type { AuthData, Config, Logger } from '../../../types';
 
 /**
  * Database info returned from selection
@@ -39,7 +37,13 @@ export async function selectOrCreateDatabase(options: {
 }): Promise<DatabaseInfo> {
 	const { logger, auth, orgId, config, existingUrl, projectDir } = options;
 	const profileName = config?.name;
-	const globalClient = await getGlobalCatalystAPIClient(logger, auth, profileName);
+	const globalClient = await getGlobalCatalystAPIClient(
+		logger,
+		auth,
+		profileName,
+		undefined,
+		config
+	);
 
 	const resources = await tui.spinner({
 		message: `Fetching databases for ${orgId}`,
@@ -122,7 +126,7 @@ export async function selectOrCreateDatabase(options: {
 			logger.trace(`[auth init] Using fallback region: ${region}`);
 		}
 
-		const regionalClient = getCatalystAPIClient(logger, auth, region);
+		const regionalClient = getCatalystAPIClient(logger, auth, region, undefined, config);
 
 		const created = await tui.spinner({
 			message: `Creating database in ${region}`,
@@ -393,9 +397,10 @@ export async function runAuthMigrations(options: {
 	region: string;
 	databaseName: string;
 	sql: string;
+	config?: Config | null;
 }): Promise<void> {
-	const { logger, auth, orgId, region, databaseName, sql } = options;
-	const catalystClient = getCatalystAPIClient(logger, auth, region);
+	const { logger, auth, orgId, region, databaseName, sql, config } = options;
+	const catalystClient = getCatalystAPIClient(logger, auth, region, undefined, config);
 
 	const statements = splitSqlStatements(sql);
 

package/src/cmd/project/download.ts

@@ -1,22 +1,22 @@
-import { join, resolve } from 'node:path';
 import {
+	cpSync,
+	createReadStream,
 	existsSync,
 	mkdirSync,
 	mkdtempSync,
-	renameSync,
 	readdirSync,
-	cpSync,
+	renameSync,
 	rmSync,
-	createReadStream,
 } from 'node:fs';
 import { tmpdir } from 'node:os';
+import { join, resolve } from 'node:path';
 import { finished } from 'node:stream/promises';
 import { createGunzip } from 'node:zlib';
+import { type Logger, StructuredError } from '@agentuity/core';
 import { extract, type Headers } from 'tar-fs';
-import { StructuredError, type Logger } from '@agentuity/core';
-import * as tui from '../../tui';
-import { downloadWithSpinner } from '../../download';
 import { writeAgentsDocs } from '../../agents-docs';
+import { downloadWithSpinner } from '../../download';
+import * as tui from '../../tui';
 import type { TemplateInfo } from './templates';
 
 const GITHUB_BRANCH = 'main';
@@ -122,7 +122,7 @@ async function _cleanup(sourceDir: string, dest: string) {
 		});
 	}
 
-	await tui.spinner(`📦 Copying template files...`, async () => {
+	await tui.spinner('📦 Copying template files...', async () => {
 		// Copy all files from source to dest
 		const files = readdirSync(sourceDir);
 		for (const file of files) {
@@ -275,7 +275,7 @@ export async function downloadTemplate(options: DownloadOptions): Promise<void>
 			},
 			// ignore callback: called AFTER map, receives the MAPPED name
 			// Return true to skip the entry, false to extract it
-			ignore: (name: string, header?: Headers) => {
+			ignore: (_name: string, header?: Headers) => {
 				if (!header) {
 					ignoredCount++;
 					return true;
@@ -396,7 +396,21 @@ export async function setupProject(options: SetupOptions): Promise<{ success: bo
 	return { success: !hasError };
 }
 
-export async function initGitRepo(dest: string): Promise<void> {
+interface InitGitRepoOptions {
+	/** Project name (e.g. "My Agent") */
+	projectName?: string;
+	/** Where the template came from (e.g. "github.com/owner/repo" or "TypeScript / Hello World") */
+	source?: string;
+	/** Git commit author (e.g. { name: "app-slug[bot]", email: "id+slug[bot]@users.noreply.github.com" }) */
+	author?: { name: string; email: string };
+}
+
+export async function initGitRepo(dest: string, options?: InitGitRepoOptions): Promise<void> {
+	// Safety: refuse to init if .git already exists (prevents clobbering existing repos)
+	if (existsSync(join(dest, '.git'))) {
+		throw new Error(`Refusing to initialize git: "${dest}" already contains a .git directory.`);
+	}
+
 	// Initialize git repository if git is available
 	// Check for real git (not macOS stub that triggers Xcode CLT popup)
 	const { isGitAvailable, getDefaultBranch } = await import('../../git-helper');
@@ -414,19 +428,22 @@ export async function initGitRepo(dest: string): Promise<void> {
 			clearOnSuccess: true,
 		});
 
-		// Configure git user in CI environments (where git config may not be set)
-		if (process.env.CI) {
+		// Configure git user in CI/sandbox environments (where git config may not be set)
+		if (process.env.CI || process.env.AGENTUITY_SANDBOX_ID) {
+			const cfgEmail = options?.author?.email ?? 'bot@agentuity.com';
+			const cfgName = options?.author?.name ?? 'Agentuity';
+
 			await tui.runCommand({
 				command: 'git config user.email',
 				cwd: dest,
-				cmd: ['git', 'config', 'user.email', 'agentuity@example.com'],
+				cmd: ['git', 'config', 'user.email', cfgEmail],
 				clearOnSuccess: true,
 			});
 
 			await tui.runCommand({
 				command: 'git config user.name',
 				cwd: dest,
-				cmd: ['git', 'config', 'user.name', 'Agentuity'],
+				cmd: ['git', 'config', 'user.name', cfgName],
 				clearOnSuccess: true,
 			});
 		}
@@ -439,11 +456,30 @@ export async function initGitRepo(dest: string): Promise<void> {
 			clearOnSuccess: true,
 		});
 
-		// Create initial commit (disable GPG signing to avoid lock issues)
+		const commitMessage = 'Initial Setup';
+
+		// Create initial commit — authored by the GitHub App bot if available,
+		// otherwise fallback to generic Agentuity identity
+		const authorName = options?.author?.name ?? 'Agentuity';
+		const authorEmail = options?.author?.email ?? 'bot@agentuity.com';
+		const authorStr = `${authorName} <${authorEmail}>`;
+
 		await tui.runCommand({
-			command: 'git commit -m "Initial Setup"',
+			command: 'git commit',
 			cwd: dest,
-			cmd: ['git', '-c', 'commit.gpgsign=false', 'commit', '-m', 'Initial Setup'],
+			cmd: [
+				'git',
+				'-c',
+				'commit.gpgsign=false',
+				'commit',
+				`--author=${authorStr}`,
+				'-m',
+				commitMessage,
+			],
+			env: {
+				GIT_COMMITTER_NAME: authorName,
+				GIT_COMMITTER_EMAIL: authorEmail,
+			},
 			clearOnSuccess: true,
 		});
 	}