@agentuity/cli 0.0.110 → 0.0.111

package/src/cmd/dev/index.ts

@@ -680,7 +680,34 @@ export const command = createCommand({
 								);
 							}
 
-							// Step 2: Generate entry file with workbench config
+							// Step 2: Discover agents and routes for registry generation
+							const srcDir = join(rootDir, 'src');
+							const { discoverAgents } = await import('../build/vite/agent-discovery');
+							const { discoverRoutes } = await import('../build/vite/route-discovery');
+							const { generateAgentRegistry, generateRouteRegistry } = await import(
+								'../build/vite/registry-generator'
+							);
+
+							const agentMetadata = await discoverAgents(
+								srcDir,
+								project?.projectId ?? '',
+								deploymentId,
+								logger
+							);
+							const { routes, routeInfoList } = await discoverRoutes(
+								srcDir,
+								project?.projectId ?? '',
+								deploymentId,
+								logger
+							);
+
+							// Generate agent and route registries for type augmentation
+							// (TypeScript needs these files to exist for proper type inference)
+							generateAgentRegistry(srcDir, agentMetadata);
+							generateRouteRegistry(srcDir, routeInfoList);
+							logger.debug('Agent and route registries generated for dev mode');
+
+							// Step 3: Generate entry file with workbench config
 							// Note: vitePort is NOT passed here - the app reads process.env.VITE_PORT at runtime
 							const { generateEntryFile } = await import('../build/entry-generator');
 							await generateEntryFile({
@@ -692,7 +719,7 @@ export const command = createCommand({
 								workbench: workbenchConfigData.enabled ? workbenchConfigData : undefined,
 							});
 
-							// Step 3: Bundle the app with LLM patches (dev mode = no minification)
+							// Step 4: Bundle the app with LLM patches (dev mode = no minification)
 							// This produces .agentuity/app.js with AI Gateway routing patches applied
 							const { installExternalsAndBuild } = await import(
 								'../build/vite/server-bundler'
@@ -704,14 +731,11 @@ export const command = createCommand({
 							});
 
 							// Generate metadata file (needed for eval ID lookup at runtime)
-							const { discoverAgents } = await import('../build/vite/agent-discovery');
-							const { discoverRoutes } = await import('../build/vite/route-discovery');
+							// Reuse agentMetadata and routes from Step 2
 							const { generateMetadata, writeMetadataFile } = await import(
 								'../build/vite/metadata-generator'
 							);
 
-							const srcDir = join(rootDir, 'src');
-
 							const promises: Promise<void>[] = [];
 
 							// Generate/update prompt files (non-blocking)
@@ -722,25 +746,13 @@ export const command = createCommand({
 										logger.warn('Failed to generate prompt files: %s', err.message)
 									)
 							);
-							const agents = await discoverAgents(
-								srcDir,
-								project?.projectId ?? '',
-								deploymentId,
-								logger
-							);
-							const { routes } = await discoverRoutes(
-								srcDir,
-								project?.projectId ?? '',
-								deploymentId,
-								logger
-							);
 
 							const metadata = await generateMetadata({
 								rootDir,
 								projectId: project?.projectId ?? '',
 								orgId: project?.orgId ?? '',
 								deploymentId,
-								agents,
+								agents: agentMetadata,
 								routes,
 								dev: true,
 								logger,
@@ -844,6 +856,7 @@ export const command = createCommand({
 						process.env.AGENTUITY_STREAM_URL = serviceUrls.stream;
 						process.env.AGENTUITY_CLOUD_ORG_ID = project.orgId;
 						process.env.AGENTUITY_CLOUD_PROJECT_ID = project.projectId;
+						process.env.AGENTUITY_CLOUD_DEPLOYMENT_ID = deploymentId;
 					}
 
 					// Set Vite port for asset proxying in bundled app

package/src/cmd/dev/sync.ts

@@ -15,7 +15,7 @@ interface AgentSyncPayload {
 interface EvalSyncPayload {
 	id: string;
 	name: string;
-	evalId: string;
+	identifier: string;
 	description?: string;
 	version: string;
 	filename: string;
@@ -100,7 +100,7 @@ function getEvalsToSync(
 
 					evalsToCreate.push({
 						...evalItem,
-						evalId: evalItem.evalId,
+						identifier: evalItem.identifier,
 						projectId,
 						agentIdentifier: agent.agentId,
 					});
@@ -133,18 +133,28 @@ class DevmodeSyncService implements IDevmodeSyncService {
 		projectId: string,
 		deploymentId: string
 	): Promise<void> {
+		this.logger.debug(
+			'[CLI SYNC] sync() called with projectId=%s, deploymentId=%s',
+			projectId,
+			deploymentId
+		);
+		this.logger.debug(
+			'[CLI SYNC] currentMetadata has %d agents',
+			currentMetadata.agents?.length ?? 0
+		);
+
 		// Build previous agent IDs set
 		const previousAgentIds = new Set<string>();
 		if (previousMetadata) {
 			this.logger.debug(
-				'Previous metadata found with %d agent(s)',
+				'[CLI SYNC] Previous metadata found with %d agent(s)',
 				previousMetadata.agents?.length ?? 0
 			);
 			for (const agent of previousMetadata.agents || []) {
 				previousAgentIds.add(agent.id);
 			}
 		} else {
-			this.logger.debug('No previous metadata, all agents will be treated as new');
+			this.logger.debug('[CLI SYNC] No previous metadata, all agents will be treated as new');
 		}
 
 		// Build previous eval IDs set
@@ -178,9 +188,10 @@ class DevmodeSyncService implements IDevmodeSyncService {
 				);
 				for (const evalItem of agent.evals) {
 					this.logger.debug(
-						'[CLI EVAL SYNC]   - %s (evalId: %s)',
+						'[CLI EVAL SYNC]   - %s (id: %s, identifier: %s)',
 						evalItem.name,
-						evalItem.evalId
+						evalItem.id,
+						evalItem.identifier
 					);
 				}
 			}
@@ -208,13 +219,11 @@ class DevmodeSyncService implements IDevmodeSyncService {
 				agentsToDelete.length
 			);
 		}
-		if (evalsToCreate.length > 0 || evalsToDelete.length > 0) {
-			this.logger.debug(
-				'Bulk syncing %d eval(s) to create, %d eval(s) to delete',
-				evalsToCreate.length,
-				evalsToDelete.length
-			);
-		}
+		this.logger.debug(
+			'[CLI EVAL SYNC] Evals to sync: %d to create, %d to delete',
+			evalsToCreate.length,
+			evalsToDelete.length
+		);
 
 		// Sync both in parallel
 		try {
@@ -273,14 +282,7 @@ class DevmodeSyncService implements IDevmodeSyncService {
 		evalsToDelete: string[],
 		deploymentId: string
 	): Promise<void> {
-		this.logger.debug(
-			'[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;
 		}
 
@@ -290,15 +292,10 @@ class DevmodeSyncService implements IDevmodeSyncService {
 			delete: evalsToDelete,
 		};
 
-		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
-			);
-		}
+		this.logger.debug(
+			'[CLI EVAL SYNC] Sending payload to POST /cli/devmode/eval: %s',
+			JSON.stringify(payload, null, 2)
+		);
 
 		try {
 			await this.apiClient.post(
@@ -306,7 +303,6 @@ class DevmodeSyncService implements IDevmodeSyncService {
 				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/git/account/add.ts

@@ -0,0 +1,317 @@
+import { createSubcommand } from '../../../types';
+import type { Config } from '../../../types';
+import * as tui from '../../../tui';
+import { getCommand } from '../../../command-prefix';
+import { getAPIBaseURL } from '../../../api';
+import type { APIClient } from '../../../api';
+import { ErrorCode } from '../../../errors';
+import { listOrganizations } from '@agentuity/server';
+import enquirer from 'enquirer';
+import type { Logger } from '@agentuity/core';
+import { z } from 'zod';
+import {
+	startGithubIntegration,
+	pollForGithubIntegration,
+	getGithubIntegrationStatus,
+	getExistingGithubIntegrations,
+	copyGithubIntegration,
+} from '../../integration/api';
+
+export interface RunGitAccountConnectOptions {
+	apiClient: APIClient;
+	orgId: string;
+	orgName?: string;
+	logger: Logger;
+	config?: Config | null;
+}
+
+export interface RunGitAccountConnectResult {
+	connected: boolean;
+	cancelled?: boolean;
+}
+
+export async function runGitAccountConnect(
+	options: RunGitAccountConnectOptions
+): Promise<RunGitAccountConnectResult> {
+	const { apiClient, orgId, orgName, logger, config } = options;
+	const orgDisplay = orgName ?? orgId;
+
+	try {
+		const currentStatus = await getGithubIntegrationStatus(apiClient, orgId);
+		const initialCount = currentStatus.integrations?.length ?? 0;
+
+		const existingIntegrations = await tui.spinner({
+			message: 'Checking for existing GitHub connections...',
+			clearOnSuccess: true,
+			callback: () => getExistingGithubIntegrations(apiClient, orgId),
+		});
+
+		const alreadyConnectedNames = new Set(
+			currentStatus.integrations?.map((i) => i.githubAccountName) ?? []
+		);
+		const availableIntegrations = existingIntegrations.filter(
+			(i) => !alreadyConnectedNames.has(i.githubAccountName)
+		);
+
+		if (availableIntegrations.length > 0) {
+			tui.newline();
+
+			const integrationChoices = availableIntegrations.map((i) => ({
+				name: i.id,
+				message: `${i.githubAccountName} ${tui.muted(`(from ${i.orgName})`)}`,
+			}));
+
+			console.log(tui.muted('Press enter with none selected to add a new account'));
+			tui.newline();
+
+			const selectResponse = await enquirer.prompt<{ integrationIds: string[] }>({
+				type: 'multiselect',
+				name: 'integrationIds',
+				message: 'Select GitHub accounts to add',
+				choices: integrationChoices,
+			});
+
+			if (selectResponse.integrationIds.length > 0) {
+				const selectedIntegrations = availableIntegrations.filter((i) =>
+					selectResponse.integrationIds.includes(i.id)
+				);
+
+				const accountNames = selectedIntegrations.map((i) => i.githubAccountName).join(', ');
+
+				const confirmResponse = await enquirer.prompt<{ confirm: boolean }>({
+					type: 'confirm',
+					name: 'confirm',
+					message: `Add ${tui.bold(accountNames)} to ${tui.bold(orgDisplay)}?`,
+					initial: true,
+				});
+
+				if (confirmResponse.confirm) {
+					await tui.spinner({
+						message: `Adding ${selectedIntegrations.length} GitHub account${selectedIntegrations.length > 1 ? 's' : ''}...`,
+						clearOnSuccess: true,
+						callback: async () => {
+							for (const integration of selectedIntegrations) {
+								await copyGithubIntegration(apiClient, integration.orgId, orgId);
+							}
+						},
+					});
+
+					tui.newline();
+					tui.success(
+						`Added GitHub account${selectedIntegrations.length > 1 ? 's' : ''} to ${tui.bold(orgDisplay)}`
+					);
+					return { connected: true };
+				}
+			}
+		}
+
+		const startResult = await tui.spinner({
+			message: 'Getting GitHub authorization URL...',
+			clearOnSuccess: true,
+			callback: () => startGithubIntegration(apiClient, orgId),
+		});
+
+		if (!startResult) {
+			tui.error('Failed to start GitHub authorization');
+			return { connected: false };
+		}
+
+		const { shortId } = startResult;
+		const apiBaseUrl = getAPIBaseURL(config);
+		const url = `${apiBaseUrl}/github/connect/${shortId}`;
+
+		const copied = await tui.copyToClipboard(url);
+
+		tui.newline();
+		if (copied) {
+			console.log('GitHub authorization URL copied to clipboard! Open it in your browser:');
+		} else {
+			console.log('Open this URL in your browser to authorize GitHub access:');
+		}
+		tui.newline();
+		console.log(`  ${tui.link(url)}`);
+		tui.newline();
+		console.log(tui.muted('Press Enter to open in your browser, or Ctrl+C to cancel'));
+		tui.newline();
+
+		const result = await tui.spinner({
+			type: 'countdown',
+			message: 'Waiting for GitHub authorization',
+			timeoutMs: 600000,
+			clearOnSuccess: true,
+			onEnterPress: () => {
+				const platform = process.platform;
+				if (platform === 'win32') {
+					Bun.spawn(['cmd', '/c', 'start', '', url], {
+						stdout: 'ignore',
+						stderr: 'ignore',
+					});
+				} else {
+					const command = platform === 'darwin' ? 'open' : 'xdg-open';
+					Bun.spawn([command, url], { stdout: 'ignore', stderr: 'ignore' });
+				}
+			},
+			callback: async () => {
+				return await pollForGithubIntegration(apiClient, orgId, initialCount);
+			},
+		});
+
+		tui.newline();
+		if (result.connected) {
+			tui.success(`GitHub account added to ${tui.bold(orgDisplay)}`);
+			return { connected: true };
+		}
+
+		return { connected: false };
+	} catch (error) {
+		const isCancel =
+			error === '' ||
+			(error instanceof Error && (error.message === '' || error.message === 'User cancelled'));
+
+		if (isCancel) {
+			tui.newline();
+			tui.info('Cancelled');
+			return { connected: false, cancelled: true };
+		}
+
+		logger.trace(error);
+		throw error;
+	}
+}
+
+const AddOptionsSchema = z.object({
+	org: z.string().optional().describe('Organization ID to add the account to'),
+});
+
+const AddResponseSchema = z.object({
+	connected: z.boolean().describe('Whether the account was connected'),
+	orgId: z.string().optional().describe('Organization ID'),
+});
+
+export const addSubcommand = createSubcommand({
+	name: 'add',
+	description: 'Add a GitHub account to your organization',
+	tags: ['mutating', 'creates-resource', 'slow', 'api-intensive'],
+	idempotent: false,
+	requires: { auth: true, apiClient: true },
+	schema: {
+		options: AddOptionsSchema,
+		response: AddResponseSchema,
+	},
+	examples: [
+		{
+			command: getCommand('git account add'),
+			description: 'Add a GitHub account to your organization',
+		},
+		{
+			command: getCommand('git account add --org org_abc123'),
+			description: 'Add to a specific organization',
+		},
+	],
+
+	async handler(ctx) {
+		const { logger, apiClient, config, opts } = ctx;
+
+		try {
+			const orgs = await tui.spinner({
+				message: 'Fetching organizations...',
+				clearOnSuccess: true,
+				callback: () => listOrganizations(apiClient),
+			});
+
+			if (orgs.length === 0) {
+				tui.fatal('No organizations found for your account');
+			}
+
+			let orgId = opts.org;
+			let selectedOrg: (typeof orgs)[0] | undefined;
+
+			if (orgId) {
+				selectedOrg = orgs.find((o) => o.id === orgId);
+				if (!selectedOrg) {
+					tui.fatal(`Organization ${orgId} not found`);
+				}
+			} else {
+				const orgStatuses = await tui.spinner({
+					message: 'Checking GitHub integration status...',
+					clearOnSuccess: true,
+					callback: async () => {
+						const statuses = await Promise.all(
+							orgs.map(async (org) => {
+								const status = await getGithubIntegrationStatus(apiClient, org.id);
+								return {
+									...org,
+									connected: status.connected,
+									integrations: status.integrations,
+								};
+							})
+						);
+						return statuses;
+					},
+				});
+
+				const sortedOrgs = [...orgStatuses].sort((a, b) => a.name.localeCompare(b.name));
+
+				if (orgs.length === 1) {
+					orgId = orgs[0].id;
+					selectedOrg = orgs[0];
+				} else {
+					const choices = sortedOrgs.map((org) => {
+						const count = org.integrations.length;
+						const suffix =
+							count > 0
+								? tui.muted(` (${count} GitHub account${count > 1 ? 's' : ''})`)
+								: '';
+						return {
+							name: org.name,
+							message: `${org.name}${suffix}`,
+							value: org.id,
+						};
+					});
+
+					const response = await enquirer.prompt<{ orgName: string }>({
+						type: 'select',
+						name: 'orgName',
+						message: 'Select an organization',
+						choices,
+						result(name: string) {
+							// @ts-expect-error - this.map exists at runtime
+							return this.map(name)[name];
+						},
+					});
+
+					orgId = response.orgName;
+					selectedOrg = sortedOrgs.find((o) => o.id === orgId);
+				}
+			}
+
+			const result = await runGitAccountConnect({
+				apiClient,
+				orgId: orgId!,
+				orgName: selectedOrg?.name,
+				logger,
+				config,
+			});
+
+			return { connected: result.connected, orgId };
+		} catch (error) {
+			const isCancel =
+				error === '' ||
+				(error instanceof Error &&
+					(error.message === '' || error.message === 'User cancelled'));
+
+			if (isCancel) {
+				tui.newline();
+				tui.info('Cancelled');
+				return { connected: false };
+			}
+
+			logger.trace(error);
+			return logger.fatal(
+				'Failed to add GitHub account: %s',
+				error,
+				ErrorCode.INTEGRATION_FAILED
+			);
+		}
+	},
+});

package/src/cmd/git/account/index.ts

@@ -0,0 +1,12 @@
+import { createCommand } from '../../../types';
+import { addSubcommand } from './add';
+import { removeSubcommand } from './remove';
+import { listSubcommand } from './list';
+
+export const accountCommand = createCommand({
+	name: 'account',
+	description: 'Manage GitHub accounts connected to your organization',
+	subcommands: [addSubcommand, removeSubcommand, listSubcommand],
+});
+
+export default accountCommand;

package/src/cmd/git/account/list.ts

@@ -0,0 +1,139 @@
+import { createSubcommand } from '../../../types';
+import * as tui from '../../../tui';
+import { getCommand } from '../../../command-prefix';
+import { ErrorCode } from '../../../errors';
+import { listOrganizations } from '@agentuity/server';
+import { getGithubIntegrationStatus } from '../../integration/api';
+import { z } from 'zod';
+
+const ListResponseSchema = z.array(
+	z.object({
+		orgId: z.string().describe('Organization ID'),
+		orgName: z.string().describe('Organization name'),
+		integrations: z.array(
+			z.object({
+				id: z.string().describe('Integration ID'),
+				githubAccountName: z.string().describe('GitHub account name'),
+				githubAccountType: z.enum(['user', 'org']).describe('Account type'),
+			})
+		),
+	})
+);
+
+export const listSubcommand = createSubcommand({
+	name: 'list',
+	description: 'List GitHub accounts connected to your organizations',
+	aliases: ['ls'],
+	tags: ['read-only'],
+	idempotent: true,
+	requires: { auth: true, apiClient: true },
+	schema: {
+		response: ListResponseSchema,
+	},
+	examples: [
+		{
+			command: getCommand('git account list'),
+			description: 'List all connected GitHub accounts',
+		},
+		{
+			command: getCommand('--json git account list'),
+			description: 'List accounts in JSON format',
+		},
+	],
+
+	async handler(ctx) {
+		const { logger, apiClient, options } = ctx;
+
+		try {
+			// Fetch organizations
+			const orgs = await tui.spinner({
+				message: 'Fetching organizations...',
+				clearOnSuccess: true,
+				callback: () => listOrganizations(apiClient),
+			});
+
+			if (orgs.length === 0) {
+				tui.fatal('No organizations found for your account');
+			}
+
+			// Check GitHub status for each org
+			const orgStatuses = await tui.spinner({
+				message: 'Checking GitHub integration status...',
+				clearOnSuccess: true,
+				callback: async () => {
+					const statuses = await Promise.all(
+						orgs.map(async (org) => {
+							const status = await getGithubIntegrationStatus(apiClient, org.id);
+							return {
+								...org,
+								connected: status.connected,
+								integrations: status.integrations,
+							};
+						})
+					);
+					return statuses;
+				},
+			});
+
+			// Sort orgs alphabetically
+			const sortedOrgs = [...orgStatuses].sort((a, b) => a.name.localeCompare(b.name));
+
+			const result = sortedOrgs.map((org) => ({
+				orgId: org.id,
+				orgName: org.name,
+				integrations: org.integrations.map((i) => ({
+					id: i.id,
+					githubAccountName: i.githubAccountName,
+					githubAccountType: i.githubAccountType,
+				})),
+			}));
+
+			if (options.json) {
+				return result;
+			}
+
+			tui.newline();
+			console.log(tui.bold('GitHub Accounts'));
+			tui.newline();
+
+			let totalCount = 0;
+
+			for (const org of sortedOrgs) {
+				if (org.integrations.length === 0) {
+					console.log(`  ${org.name} ${tui.muted('(no accounts connected)')}`);
+				} else {
+					console.log(`  ${org.name}`);
+					for (const integration of org.integrations) {
+						const typeLabel = integration.githubAccountType === 'org' ? 'org' : 'user';
+						console.log(
+							`    ${tui.colorSuccess('✓')} ${integration.githubAccountName} ${tui.muted(`(${typeLabel})`)}`
+						);
+						totalCount++;
+					}
+				}
+			}
+
+			tui.newline();
+			if (totalCount === 0) {
+				console.log(
+					tui.muted(
+						`No GitHub accounts connected. Run ${tui.bold('agentuity git account add')} to add one.`
+					)
+				);
+			} else {
+				console.log(
+					tui.muted(`${totalCount} GitHub account${totalCount > 1 ? 's' : ''} connected`)
+				);
+			}
+
+			return result;
+		} catch (error) {
+			logger.trace(error);
+			return logger.fatal(
+				'Failed to list GitHub accounts: %s',
+				error,
+				ErrorCode.INTEGRATION_FAILED
+			);
+		}
+	},
+});