@agentuity/cli 1.0.32 → 1.0.33

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) {
@@ -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,
 		});
 	}

package/src/cmd/project/import.ts

@@ -1,11 +1,12 @@
-import { z } from 'zod';
 import { resolve } from 'node:path';
-import { createSubcommand } from '../../types';
+import { z } from 'zod';
+import { isTTY } from '../../auth';
 import { getCommand } from '../../command-prefix';
-import { runProjectImport } from './reconcile';
-import * as tui from '../../tui';
 import { ErrorCode } from '../../errors';
-import { isTTY } from '../../auth';
+import * as tui from '../../tui';
+import { createSubcommand } from '../../types';
+import { runProjectImport } from './reconcile';
+import { runRemoteImport } from './remote-import';
 
 const ProjectImportResponseSchema = z.object({
 	success: z.boolean().describe('Whether the import succeeded'),
@@ -20,19 +21,37 @@ const ProjectImportResponseSchema = z.object({
 
 export const importSubcommand = createSubcommand({
 	name: 'import',
-	description: 'Import or register a local project with Agentuity Cloud',
+	description: 'Import or register a local or remote project with Agentuity Cloud',
 	tags: ['mutating', 'creates-resource', 'requires-auth'],
 	examples: [
-		{ command: getCommand('project import'), description: 'Import project in current directory' },
+		{
+			command: getCommand('project import'),
+			description: 'Import project in current directory',
+		},
 		{
 			command: getCommand('project import --dir ./my-agent'),
 			description: 'Import project from specified directory',
 		},
+		{
+			command: getCommand('project import --source owner/repo'),
+			description: 'Import a remote project from GitHub',
+		},
+		{
+			command: getCommand('project import --source owner/repo --deploy --name my-agent'),
+			description: 'Import remote project, name it, and deploy',
+		},
+		{
+			command: getCommand(
+				'project import --source owner/repo --remote owner/new-repo --env DATABASE_URL:my_db --env TASK_QUEUE:my_queue'
+			),
+			description: 'Import with resource provisioning and push to new repo',
+		},
 	],
 	requires: { auth: true, apiClient: true },
-	optional: { region: true },
+	optional: { region: true, org: true },
 	schema: {
 		options: z.object({
+			source: z.string().optional().describe('GitHub URL or owner/repo to import from'),
 			dir: z
 				.string()
 				.optional()
@@ -41,17 +60,60 @@ export const importSubcommand = createSubcommand({
 				.boolean()
 				.optional()
 				.describe('Only validate the project structure without prompting'),
+			deploy: z
+				.boolean()
+				.optional()
+				.default(false)
+				.describe('Deploy the project after importing'),
+			projectId: z.string().optional().describe('Use a pre-created project ID (skip creation)'),
+			remote: z
+				.string()
+				.optional()
+				.describe('Target GitHub repo (owner/repo) to push imported code to'),
+			name: z.string().optional().describe('Project name (for non-interactive mode)'),
+			env: z
+				.array(z.string())
+				.optional()
+				.describe('Set env vars or name resources (KEY:VALUE format, repeatable)'),
 		}),
 		response: ProjectImportResponseSchema,
 	},
 
 	async handler(ctx) {
-		const { opts, auth, apiClient, config, logger } = ctx;
+		const { opts, auth, apiClient, config, logger, orgId, region } = ctx;
 
 		if (!config) {
 			tui.fatal('Configuration not loaded. Please try again.', ErrorCode.CONFIG_INVALID);
 		}
 
+		// If --source is provided, run remote import flow
+		const source = opts.source;
+		if (source) {
+			// Normalize owner/repo shorthand to full GitHub URL
+			const url = source.includes('://') ? source : `https://github.com/${source}`;
+			await runRemoteImport({
+				url,
+				deploy: opts.deploy ?? false,
+				projectId: opts.projectId,
+				repo: opts.remote,
+				name: opts.name,
+				env: opts.env,
+				org: orgId,
+				region,
+				apiClient,
+				auth,
+				config,
+				logger,
+			});
+
+			return {
+				success: true,
+				status: 'imported' as const,
+				message: 'Remote project imported successfully',
+			};
+		}
+
+		// No URL — fall through to existing local import behavior
 		const dir = opts.dir ? resolve(opts.dir) : process.cwd();
 		const validateOnly = opts.validateOnly ?? false;