@agentuity/cli 1.0.13 → 1.0.15

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

@@ -1,31 +1,28 @@
-import { createSubcommand } from '../../../types';
-import * as tui from '../../../tui';
-import { getCommand } from '../../../command-prefix';
-import { ErrorCode } from '../../../errors';
-import { listOrganizations } from '@agentuity/server';
 import enquirer from 'enquirer';
 import { z } from 'zod';
+import { getCommand } from '../../../command-prefix';
+import { ErrorCode } from '../../../errors';
+import * as tui from '../../../tui';
+import { createSubcommand } from '../../../types';
 import {
-	getGithubIntegrationStatus,
 	disconnectGithubIntegration,
-	type GithubIntegration,
+	type GithubInstallation,
+	getGithubIntegrationStatus,
 } from '../api';
 
 const RemoveOptionsSchema = z.object({
-	org: z.string().optional().describe('Organization ID'),
-	account: z.string().optional().describe('GitHub integration ID to remove'),
+	account: z.string().optional().describe('Installation ID to remove'),
 	confirm: z.boolean().optional().describe('Skip confirmation prompt'),
 });
 
 const RemoveResponseSchema = z.object({
-	removed: z.boolean().describe('Whether the account was removed'),
-	orgId: z.string().optional().describe('Organization ID'),
-	integrationId: z.string().optional().describe('Integration ID that was removed'),
+	removed: z.boolean().describe('Whether the installation was removed'),
+	installationId: z.string().optional().describe('Installation ID that was removed'),
 });
 
 export const removeSubcommand = createSubcommand({
 	name: 'remove',
-	description: 'Remove a GitHub account from your organization',
+	description: 'Remove a GitHub App installation',
 	tags: ['mutating', 'destructive', 'slow'],
 	idempotent: false,
 	requires: { auth: true, apiClient: true },
@@ -36,14 +33,14 @@ export const removeSubcommand = createSubcommand({
 	examples: [
 		{
 			command: getCommand('git account remove'),
-			description: 'Remove a GitHub account from your organization',
+			description: 'Remove a GitHub App installation',
 		},
 		{
-			command: getCommand('git account remove --org org_abc --account int_xyz --confirm'),
-			description: 'Remove a specific account without prompts',
+			command: getCommand('git account remove --account inst_xyz --confirm'),
+			description: 'Remove a specific installation without prompts',
 		},
 		{
-			command: getCommand('--json git account remove --org org_abc --account int_xyz --confirm'),
+			command: getCommand('--json git account remove --account inst_xyz --confirm'),
 			description: 'Remove and return JSON result',
 		},
 	],
@@ -52,11 +49,11 @@ export const removeSubcommand = createSubcommand({
 		const { logger, apiClient, opts, options } = ctx;
 
 		try {
-			// If both org and account provided, skip interactive flow
-			if (opts.org && opts.account) {
+			// If --account provided directly, skip interactive flow
+			if (opts.account) {
 				if (!opts.confirm) {
 					const confirmed = await tui.confirm(
-						`Are you sure you want to remove this GitHub account?`
+						'Are you sure you want to remove this GitHub installation?'
 					);
 					if (!confirmed) {
 						tui.info('Cancelled');
@@ -65,107 +62,61 @@ export const removeSubcommand = createSubcommand({
 				}
 
 				await tui.spinner({
-					message: 'Removing GitHub account...',
+					message: 'Removing GitHub installation...',
 					clearOnSuccess: true,
-					callback: () => disconnectGithubIntegration(apiClient, opts.org!, opts.account!),
+					callback: () => disconnectGithubIntegration(apiClient, opts.account!),
 				});
 
 				if (!options.json) {
 					tui.newline();
-					tui.success('Removed GitHub account');
+					tui.success('Removed GitHub installation');
 				}
 
-				return { removed: true, orgId: opts.org, integrationId: opts.account };
+				return { removed: true, installationId: opts.account };
 			}
 
-			// Fetch organizations
-			const orgs = await tui.spinner({
-				message: 'Fetching organizations...',
+			// Interactive flow: get status and show picker
+			const status = await tui.spinner({
+				message: 'Checking GitHub connection...',
 				clearOnSuccess: true,
-				callback: () => listOrganizations(apiClient),
+				callback: () => getGithubIntegrationStatus(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;
-				},
-			});
-
-			// Flatten all integrations across orgs
-			const allIntegrations: Array<{
-				orgId: string;
-				orgName: string;
-				integration: GithubIntegration;
-			}> = [];
-
-			for (const org of orgStatuses) {
-				for (const integration of org.integrations) {
-					allIntegrations.push({
-						orgId: org.id,
-						orgName: org.name,
-						integration,
-					});
+			if (!status.connected || !status.identity) {
+				if (!options.json) {
+					tui.newline();
+					tui.info('No GitHub identity connected.');
 				}
+				return { removed: false };
 			}
 
-			if (allIntegrations.length === 0) {
+			if (status.installations.length === 0) {
 				if (!options.json) {
 					tui.newline();
-					tui.info('No GitHub accounts are connected.');
+					tui.info('No installations found.');
 				}
 				return { removed: false };
 			}
 
-			// Build choices showing GitHub account and org
-			const choices = allIntegrations.map((item) => ({
-				name: `${tui.bold(item.integration.githubAccountName)} ${tui.muted(`(${item.integration.githubAccountType})`)} → ${tui.bold(item.orgName)}`,
-				value: `${item.orgId}:${item.integration.id}`,
+			const choices = status.installations.map((inst: GithubInstallation) => ({
+				name: inst.installationId,
+				message: `${tui.bold(inst.accountName)} ${tui.muted(`(${inst.accountType})`)}`,
 			}));
 
-			// Show picker
+			tui.newline();
+
 			const response = await enquirer.prompt<{ selection: string }>({
 				type: 'select',
 				name: 'selection',
-				message: 'Select a GitHub account to remove',
+				message: 'Select an installation to remove',
 				choices,
-				result(name: string) {
-					// Return the value (IDs) instead of the display name
-					const choice = choices.find((c) => c.name === name);
-					return choice?.value ?? name;
-				},
 			});
 
-			const colonIdx = response.selection.indexOf(':');
-			if (colonIdx === -1) {
-				logger.fatal('Invalid selection format');
-			}
-			const orgId = response.selection.slice(0, colonIdx);
-			const integrationId = response.selection.slice(colonIdx + 1);
-			const selected = allIntegrations.find(
-				(i) => i.orgId === orgId && i.integration.id === integrationId
+			const selected = status.installations.find(
+				(i: GithubInstallation) => i.installationId === response.selection
 			);
-			const displayName = selected
-				? `${tui.bold(selected.integration.githubAccountName)} from ${tui.bold(selected.orgName)}`
-				: response.selection;
+			const displayName = selected ? tui.bold(selected.accountName) : response.selection;
 
-			// Confirm
 			if (!opts.confirm) {
 				const confirmed = await tui.confirm(`Are you sure you want to remove ${displayName}?`);
 
@@ -177,9 +128,9 @@ export const removeSubcommand = createSubcommand({
 			}
 
 			await tui.spinner({
-				message: 'Removing GitHub account...',
+				message: 'Removing GitHub installation...',
 				clearOnSuccess: true,
-				callback: () => disconnectGithubIntegration(apiClient, orgId, integrationId),
+				callback: () => disconnectGithubIntegration(apiClient, response.selection),
 			});
 
 			if (!options.json) {
@@ -187,9 +138,8 @@ export const removeSubcommand = createSubcommand({
 				tui.success(`Removed ${displayName}`);
 			}
 
-			return { removed: true, orgId, integrationId };
+			return { removed: true, installationId: response.selection };
 		} catch (error) {
-			// Handle user cancellation (Ctrl+C)
 			const isCancel =
 				error === '' ||
 				(error instanceof Error &&
@@ -203,7 +153,7 @@ export const removeSubcommand = createSubcommand({
 
 			logger.trace(error);
 			return logger.fatal(
-				'Failed to remove GitHub account: %s',
+				'Failed to remove GitHub installation: %s',
 				error,
 				ErrorCode.INTEGRATION_FAILED
 			);

package/src/cmd/git/api.ts

@@ -1,40 +1,54 @@
-import { z } from 'zod';
+import { StructuredError } from '@agentuity/core';
 import { APIResponseSchema } from '@agentuity/server';
+import { z } from 'zod';
 import type { APIClient } from '../../api';
-import { StructuredError } from '@agentuity/core';
 
 const GithubStartDataSchema = z.object({
 	shortId: z.string(),
+	hasIdentity: z.boolean(),
 });
 
-const GithubIntegrationSchema = z.object({
-	id: z.string(),
-	githubAccountName: z.string(),
-	githubAccountType: z.enum(['user', 'org']),
-	connectedBy: z.string(),
-	connectedAt: z.string(),
+const GithubInstallationSchema = z.object({
+	installationId: z.string(),
+	integrationId: z.string().optional(),
+	accountName: z.string(),
+	accountType: z.enum(['User', 'Organization']),
+	avatarUrl: z.string().optional(),
 });
 
 const GithubStatusDataSchema = z.object({
 	connected: z.boolean(),
-	integrations: z.array(GithubIntegrationSchema).optional(),
+	identity: z
+		.object({
+			githubUsername: z.string(),
+			githubEmail: z.string().optional(),
+			avatarUrl: z.string().optional(),
+		})
+		.nullable(),
+	installations: z.array(GithubInstallationSchema),
 });
 
-export interface GithubIntegration {
-	id: string;
-	githubAccountName: string;
-	githubAccountType: 'user' | 'org';
-	connectedBy: string;
-	connectedAt: string;
+export interface GithubInstallation {
+	installationId: string;
+	integrationId?: string;
+	accountName: string;
+	accountType: 'User' | 'Organization';
+	avatarUrl?: string;
 }
 
 export interface GithubIntegrationStartResult {
 	shortId: string;
+	hasIdentity: boolean;
 }
 
 export interface GithubIntegrationStatusResult {
 	connected: boolean;
-	integrations: GithubIntegration[];
+	identity: {
+		githubUsername: string;
+		githubEmail?: string;
+		avatarUrl?: string;
+	} | null;
+	installations: GithubInstallation[];
 }
 
 const GithubIntegrationStartError = StructuredError(
@@ -43,13 +57,9 @@ const GithubIntegrationStartError = StructuredError(
 );
 
 export async function startGithubIntegration(
-	apiClient: APIClient,
-	orgId: string
+	apiClient: APIClient
 ): Promise<GithubIntegrationStartResult> {
-	const resp = await apiClient.get(
-		`/cli/github/start?orgId=${encodeURIComponent(orgId)}`,
-		APIResponseSchema(GithubStartDataSchema)
-	);
+	const resp = await apiClient.get('/cli/github/start', APIResponseSchema(GithubStartDataSchema));
 
 	if (!resp.success) {
 		throw new GithubIntegrationStartError();
@@ -59,7 +69,7 @@ export async function startGithubIntegration(
 		throw new GithubIntegrationStartError();
 	}
 
-	return { shortId: resp.data.shortId };
+	return { shortId: resp.data.shortId, hasIdentity: resp.data.hasIdentity };
 }
 
 const GithubIntegrationStatusError = StructuredError(
@@ -68,11 +78,10 @@ const GithubIntegrationStatusError = StructuredError(
 );
 
 export async function getGithubIntegrationStatus(
-	apiClient: APIClient,
-	orgId: string
+	apiClient: APIClient
 ): Promise<GithubIntegrationStatusResult> {
 	const resp = await apiClient.get(
-		`/cli/github/status?orgId=${encodeURIComponent(orgId)}`,
+		'/cli/github/status',
 		APIResponseSchema(GithubStatusDataSchema)
 	);
 
@@ -86,7 +95,8 @@ export async function getGithubIntegrationStatus(
 
 	return {
 		connected: resp.data.connected,
-		integrations: resp.data.integrations ?? [],
+		identity: resp.data.identity,
+		installations: resp.data.installations,
 	};
 }
 
@@ -105,13 +115,13 @@ const GithubDisconnectError = StructuredError(
 
 export async function disconnectGithubIntegration(
 	apiClient: APIClient,
-	orgId: string,
-	integrationId: string
+	installationId?: string
 ): Promise<GithubDisconnectResult> {
-	const resp = await apiClient.delete(
-		`/cli/github/disconnect?orgId=${encodeURIComponent(orgId)}&integrationId=${encodeURIComponent(integrationId)}`,
-		APIResponseSchema(GithubDisconnectDataSchema)
-	);
+	let url = '/cli/github/disconnect';
+	if (installationId) {
+		url += `?installationId=${encodeURIComponent(installationId)}`;
+	}
+	const resp = await apiClient.delete(url, APIResponseSchema(GithubDisconnectDataSchema));
 
 	if (!resp.success) {
 		throw new GithubDisconnectError();
@@ -124,76 +134,6 @@ export async function disconnectGithubIntegration(
 	return { disconnected: resp.data.disconnected };
 }
 
-// Existing integrations
-
-const GithubExistingIntegrationSchema = z.object({
-	id: z.string(),
-	integrationId: z.string().nullable(),
-	orgId: z.string(),
-	orgName: z.string(),
-	githubAccountName: z.string(),
-});
-
-const GithubExistingDataSchema = z.object({
-	integrations: z.array(GithubExistingIntegrationSchema),
-});
-
-export interface ExistingGithubIntegration {
-	id: string;
-	integrationId: string | null;
-	orgId: string;
-	orgName: string;
-	githubAccountName: string;
-}
-
-const GithubExistingError = StructuredError(
-	'GithubExistingError',
-	'Error fetching existing GitHub integrations'
-);
-
-export async function getExistingGithubIntegrations(
-	apiClient: APIClient,
-	excludeOrgId?: string
-): Promise<ExistingGithubIntegration[]> {
-	const query = excludeOrgId ? `?excludeOrgId=${encodeURIComponent(excludeOrgId)}` : '';
-	const resp = await apiClient.get(
-		`/cli/github/existing${query}`,
-		APIResponseSchema(GithubExistingDataSchema)
-	);
-
-	if (!resp.success || !resp.data) {
-		throw new GithubExistingError();
-	}
-
-	return resp.data.integrations;
-}
-
-// Copy integration
-
-const GithubCopyDataSchema = z.object({
-	copied: z.boolean(),
-});
-
-const GithubCopyError = StructuredError('GithubCopyError', 'Error copying GitHub integration');
-
-export async function copyGithubIntegration(
-	apiClient: APIClient,
-	fromOrgId: string,
-	toOrgId: string
-): Promise<boolean> {
-	const resp = await apiClient.post(
-		'/cli/github/copy',
-		{ fromOrgId, toOrgId },
-		APIResponseSchema(GithubCopyDataSchema)
-	);
-
-	if (!resp.success || !resp.data) {
-		throw new GithubCopyError();
-	}
-
-	return resp.data.copied;
-}
-
 // Polling
 
 const PollForGithubIntegrationError = StructuredError('PollForGithubIntegrationError');
@@ -204,7 +144,6 @@ const PollForGithubIntegrationTimeout = StructuredError(
 
 export async function pollForGithubIntegration(
 	apiClient: APIClient,
-	orgId: string,
 	initialCount: number,
 	timeoutMs = 600000 // 10 minutes
 ): Promise<GithubIntegrationStatusResult> {
@@ -214,7 +153,7 @@ export async function pollForGithubIntegration(
 
 	while (Date.now() - started < timeoutMs) {
 		const resp = await apiClient.get(
-			`/cli/github/status?orgId=${encodeURIComponent(orgId)}`,
+			'/cli/github/status',
 			APIResponseSchema(GithubStatusDataSchema)
 		);
 
@@ -222,11 +161,12 @@ export async function pollForGithubIntegration(
 			throw new PollForGithubIntegrationError();
 		}
 
-		const currentCount = resp.data.integrations?.length ?? 0;
+		const currentCount = resp.data.installations?.length ?? 0;
 		if (currentCount > initialCount) {
 			return {
 				connected: true,
-				integrations: resp.data.integrations ?? [],
+				identity: resp.data.identity,
+				installations: resp.data.installations,
 			};
 		}
 
@@ -265,12 +205,11 @@ const GithubReposError = StructuredError('GithubReposError', 'Error fetching Git
 
 export async function listGithubRepos(
 	apiClient: APIClient,
-	orgId: string,
 	integrationId?: string
 ): Promise<GithubRepo[]> {
-	let url = `/cli/github/repos?orgId=${encodeURIComponent(orgId)}`;
+	let url = '/cli/github/repos';
 	if (integrationId) {
-		url += `&integrationId=${encodeURIComponent(integrationId)}`;
+		url += `?integrationId=${encodeURIComponent(integrationId)}`;
 	}
 	const resp = await apiClient.get(url, APIResponseSchema(GithubReposDataSchema));
 
@@ -292,7 +231,6 @@ export interface LinkProjectOptions {
 	autoDeploy: boolean;
 	previewDeploy: boolean;
 	directory?: string;
-	integrationId?: string;
 }
 
 const ProjectLinkError = StructuredError('ProjectLinkError', 'Error linking project to repository');

package/src/cmd/git/identity/connect.ts

@@ -0,0 +1,178 @@
+import type { Logger } from '@agentuity/core';
+import { z } from 'zod';
+import type { APIClient } from '../../../api';
+import { getAPIBaseURL } from '../../../api';
+import { getCommand } from '../../../command-prefix';
+import { ErrorCode } from '../../../errors';
+import * as tui from '../../../tui';
+import type { Config } from '../../../types';
+import { createSubcommand } from '../../../types';
+import {
+	getGithubIntegrationStatus,
+	pollForGithubIntegration,
+	startGithubIntegration,
+} from '../api';
+
+export interface RunGitIdentityConnectOptions {
+	apiClient: APIClient;
+	logger: Logger;
+	config?: Config | null;
+}
+
+export interface RunGitIdentityConnectResult {
+	connected: boolean;
+	cancelled?: boolean;
+}
+
+export async function runGitIdentityConnect(
+	options: RunGitIdentityConnectOptions
+): Promise<RunGitIdentityConnectResult> {
+	const { apiClient, logger, config } = options;
+
+	try {
+		const currentStatus = await getGithubIntegrationStatus(apiClient);
+		const initialCount = currentStatus.installations?.length ?? 0;
+
+		if (currentStatus.connected && currentStatus.identity) {
+			tui.newline();
+			tui.info(
+				`Already connected as ${tui.bold(currentStatus.identity.githubUsername)}. Use ${tui.bold('agentuity git account add')} to install the GitHub App on additional accounts.`
+			);
+			tui.newline();
+			return { connected: true };
+		}
+
+		const startResult = await tui.spinner({
+			message: 'Getting GitHub authorization URL...',
+			clearOnSuccess: true,
+			callback: () => startGithubIntegration(apiClient),
+		});
+
+		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) {
+			tui.output('GitHub authorization URL copied to clipboard! Open it in your browser:');
+		} else {
+			tui.output('Open this URL in your browser to authorize GitHub access:');
+		}
+		tui.newline();
+		tui.output(`  ${tui.link(url)}`);
+		tui.newline();
+		tui.output(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, initialCount);
+			},
+		});
+
+		tui.newline();
+		if (result.connected) {
+			const username = result.identity?.githubUsername;
+			if (username) {
+				tui.success(`GitHub identity connected as ${tui.bold(username)}`);
+			} else {
+				tui.success('GitHub identity connected');
+			}
+			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 ConnectOptionsSchema = z.object({});
+
+const ConnectResponseSchema = z.object({
+	connected: z.boolean().describe('Whether the identity was connected'),
+});
+
+export const connectSubcommand = createSubcommand({
+	name: 'connect',
+	description: 'Connect your GitHub identity',
+	tags: ['mutating', 'creates-resource', 'slow', 'api-intensive'],
+	idempotent: false,
+	requires: { auth: true, apiClient: true },
+	schema: {
+		options: ConnectOptionsSchema,
+		response: ConnectResponseSchema,
+	},
+	examples: [
+		{
+			command: getCommand('git identity connect'),
+			description: 'Connect your GitHub identity',
+		},
+	],
+
+	async handler(ctx) {
+		const { logger, apiClient, config } = ctx;
+
+		try {
+			const result = await runGitIdentityConnect({
+				apiClient,
+				logger,
+				config,
+			});
+
+			return { connected: result.connected };
+		} 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 connect GitHub identity: %s',
+				error,
+				ErrorCode.INTEGRATION_FAILED
+			);
+		}
+	},
+});