@agentuity/cli 0.0.110 → 0.0.111

package/src/cmd/integration/api.ts

@@ -0,0 +1,379 @@
+import { z } from 'zod';
+import { APIResponseSchema } from '@agentuity/server';
+import type { APIClient } from '../../api';
+import { StructuredError } from '@agentuity/core';
+
+const GithubStartDataSchema = z.object({
+	shortId: z.string(),
+});
+
+const GithubIntegrationSchema = z.object({
+	id: z.string(),
+	githubAccountName: z.string(),
+	githubAccountType: z.enum(['user', 'org']),
+	connectedBy: z.string(),
+	connectedAt: z.string(),
+});
+
+const GithubStatusDataSchema = z.object({
+	connected: z.boolean(),
+	integrations: z.array(GithubIntegrationSchema).optional(),
+});
+
+export interface GithubIntegration {
+	id: string;
+	githubAccountName: string;
+	githubAccountType: 'user' | 'org';
+	connectedBy: string;
+	connectedAt: string;
+}
+
+export interface GithubIntegrationStartResult {
+	shortId: string;
+}
+
+export interface GithubIntegrationStatusResult {
+	connected: boolean;
+	integrations: GithubIntegration[];
+}
+
+const GithubIntegrationStartError = StructuredError(
+	'GithubIntegrationStartError',
+	'Error starting GitHub integration flow'
+);
+
+export async function startGithubIntegration(
+	apiClient: APIClient,
+	orgId: string
+): Promise<GithubIntegrationStartResult> {
+	const resp = await apiClient.get(
+		`/cli/github/start?orgId=${encodeURIComponent(orgId)}`,
+		APIResponseSchema(GithubStartDataSchema)
+	);
+
+	if (!resp.success) {
+		throw new GithubIntegrationStartError();
+	}
+
+	if (!resp.data) {
+		throw new GithubIntegrationStartError();
+	}
+
+	return { shortId: resp.data.shortId };
+}
+
+const GithubIntegrationStatusError = StructuredError(
+	'GithubIntegrationStatusError',
+	'Error checking GitHub integration status'
+);
+
+export async function getGithubIntegrationStatus(
+	apiClient: APIClient,
+	orgId: string
+): Promise<GithubIntegrationStatusResult> {
+	const resp = await apiClient.get(
+		`/cli/github/status?orgId=${encodeURIComponent(orgId)}`,
+		APIResponseSchema(GithubStatusDataSchema)
+	);
+
+	if (!resp.success) {
+		throw new GithubIntegrationStatusError();
+	}
+
+	if (!resp.data) {
+		throw new GithubIntegrationStatusError();
+	}
+
+	return {
+		connected: resp.data.connected,
+		integrations: resp.data.integrations ?? [],
+	};
+}
+
+const GithubDisconnectDataSchema = z.object({
+	disconnected: z.boolean(),
+});
+
+export interface GithubDisconnectResult {
+	disconnected: boolean;
+}
+
+const GithubDisconnectError = StructuredError(
+	'GithubDisconnectError',
+	'Error disconnecting GitHub integration'
+);
+
+export async function disconnectGithubIntegration(
+	apiClient: APIClient,
+	orgId: string,
+	integrationId: string
+): Promise<GithubDisconnectResult> {
+	const resp = await apiClient.delete(
+		`/cli/github/disconnect?orgId=${encodeURIComponent(orgId)}&integrationId=${encodeURIComponent(integrationId)}`,
+		APIResponseSchema(GithubDisconnectDataSchema)
+	);
+
+	if (!resp.success) {
+		throw new GithubDisconnectError();
+	}
+
+	if (!resp.data) {
+		throw new GithubDisconnectError();
+	}
+
+	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');
+const PollForGithubIntegrationTimeout = StructuredError(
+	'PollForGithubIntegrationTimeout',
+	'Timed out waiting for GitHub integration. Aborting.'
+);
+
+export async function pollForGithubIntegration(
+	apiClient: APIClient,
+	orgId: string,
+	initialCount: number,
+	timeoutMs = 600000 // 10 minutes
+): Promise<GithubIntegrationStatusResult> {
+	const started = Date.now();
+	let delay = 2000; // Start with 2 seconds
+	const maxDelay = 10000; // Cap at 10 seconds
+
+	while (Date.now() - started < timeoutMs) {
+		const resp = await apiClient.get(
+			`/cli/github/status?orgId=${encodeURIComponent(orgId)}`,
+			APIResponseSchema(GithubStatusDataSchema)
+		);
+
+		if (!resp.success || !resp.data) {
+			throw new PollForGithubIntegrationError();
+		}
+
+		const currentCount = resp.data.integrations?.length ?? 0;
+		if (currentCount > initialCount) {
+			return {
+				connected: true,
+				integrations: resp.data.integrations ?? [],
+			};
+		}
+
+		await Bun.sleep(delay);
+		delay = Math.min(delay * 1.5, maxDelay);
+	}
+
+	throw new PollForGithubIntegrationTimeout();
+}
+
+// Project linking
+
+const GithubRepoSchema = z.object({
+	id: z.number(),
+	name: z.string(),
+	fullName: z.string(),
+	private: z.boolean(),
+	defaultBranch: z.string(),
+	integrationId: z.string(),
+});
+
+const GithubReposDataSchema = z.object({
+	repos: z.array(GithubRepoSchema),
+});
+
+export interface GithubRepo {
+	id: number;
+	name: string;
+	fullName: string;
+	private: boolean;
+	defaultBranch: string;
+	integrationId: string;
+}
+
+const GithubReposError = StructuredError('GithubReposError', 'Error fetching GitHub repositories');
+
+export async function listGithubRepos(
+	apiClient: APIClient,
+	orgId: string,
+	integrationId?: string
+): Promise<GithubRepo[]> {
+	let url = `/cli/github/repos?orgId=${encodeURIComponent(orgId)}`;
+	if (integrationId) {
+		url += `&integrationId=${encodeURIComponent(integrationId)}`;
+	}
+	const resp = await apiClient.get(url, APIResponseSchema(GithubReposDataSchema));
+
+	if (!resp.success || !resp.data) {
+		throw new GithubReposError();
+	}
+
+	return resp.data.repos;
+}
+
+const ProjectLinkDataSchema = z.object({
+	linked: z.boolean(),
+});
+
+export interface LinkProjectOptions {
+	projectId: string;
+	repoFullName: string;
+	branch: string;
+	autoDeploy: boolean;
+	previewDeploy: boolean;
+	directory?: string;
+	integrationId?: string;
+}
+
+const ProjectLinkError = StructuredError('ProjectLinkError', 'Error linking project to repository');
+
+export async function linkProjectToRepo(
+	apiClient: APIClient,
+	options: LinkProjectOptions
+): Promise<boolean> {
+	const resp = await apiClient.post(
+		'/cli/github/link',
+		options,
+		APIResponseSchema(ProjectLinkDataSchema)
+	);
+
+	if (!resp.success || !resp.data) {
+		throw new ProjectLinkError();
+	}
+
+	return resp.data.linked;
+}
+
+const ProjectUnlinkDataSchema = z.object({
+	unlinked: z.boolean(),
+});
+
+const ProjectUnlinkError = StructuredError(
+	'ProjectUnlinkError',
+	'Error unlinking project from repository'
+);
+
+export async function unlinkProjectFromRepo(
+	apiClient: APIClient,
+	projectId: string
+): Promise<boolean> {
+	const resp = await apiClient.delete(
+		`/cli/github/unlink?projectId=${encodeURIComponent(projectId)}`,
+		APIResponseSchema(ProjectUnlinkDataSchema)
+	);
+
+	if (!resp.success || !resp.data) {
+		throw new ProjectUnlinkError();
+	}
+
+	return resp.data.unlinked;
+}
+
+const ProjectGithubStatusSchema = z.object({
+	linked: z.boolean(),
+	repoFullName: z.string().optional(),
+	branch: z.string().optional(),
+	autoDeploy: z.boolean().optional(),
+	previewDeploy: z.boolean().optional(),
+	directory: z.string().optional(),
+});
+
+export interface ProjectGithubStatus {
+	linked: boolean;
+	repoFullName?: string;
+	branch?: string;
+	autoDeploy?: boolean;
+	previewDeploy?: boolean;
+	directory?: string;
+}
+
+const ProjectGithubStatusError = StructuredError(
+	'ProjectGithubStatusError',
+	'Error fetching project GitHub status'
+);
+
+export async function getProjectGithubStatus(
+	apiClient: APIClient,
+	projectId: string
+): Promise<ProjectGithubStatus> {
+	const resp = await apiClient.get(
+		`/cli/github/project-status?projectId=${encodeURIComponent(projectId)}`,
+		APIResponseSchema(ProjectGithubStatusSchema)
+	);
+
+	if (!resp.success || !resp.data) {
+		throw new ProjectGithubStatusError();
+	}
+
+	return resp.data;
+}

package/src/cmd/integration/github/connect.ts

@@ -0,0 +1,242 @@
+import { createSubcommand } from '../../../types';
+import * as tui from '../../../tui';
+import { getCommand } from '../../../command-prefix';
+import { getAPIBaseURL } from '../../../api';
+import { ErrorCode } from '../../../errors';
+import { listOrganizations } from '@agentuity/server';
+import enquirer from 'enquirer';
+import {
+	startGithubIntegration,
+	pollForGithubIntegration,
+	getGithubIntegrationStatus,
+	getExistingGithubIntegrations,
+	copyGithubIntegration,
+} from '../api';
+
+export const connectSubcommand = createSubcommand({
+	name: 'connect',
+	description: 'Connect your GitHub account to enable automatic deployments',
+	tags: ['mutating', 'creates-resource', 'slow', 'api-intensive'],
+	idempotent: false,
+	requires: { auth: true, apiClient: true },
+	examples: [
+		{
+			command: getCommand('integration github connect'),
+			description: 'Connect GitHub to your organization',
+		},
+	],
+
+	async handler(ctx) {
+		const { logger, apiClient } = 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));
+
+			// Build choices showing integration count
+			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,
+				};
+			});
+
+			// Show picker
+			const response = await enquirer.prompt<{ orgName: string }>({
+				type: 'select',
+				name: 'orgName',
+				message: 'Select an organization to connect',
+				choices,
+				result(name: string) {
+					// @ts-expect-error - this.map exists at runtime
+					return this.map(name)[name];
+				},
+			});
+
+			const orgId = response.orgName;
+			const selectedOrg = sortedOrgs.find((o) => o.id === orgId);
+			const orgDisplay = selectedOrg ? selectedOrg.name : orgId;
+			const initialCount = selectedOrg?.integrations.length ?? 0;
+
+			// Check if user has existing GitHub integrations in other orgs
+			const existingIntegrations = await tui.spinner({
+				message: 'Checking for existing GitHub connections...',
+				clearOnSuccess: true,
+				callback: () => getExistingGithubIntegrations(apiClient, orgId),
+			});
+
+			// Filter out integrations already connected to target org
+			const alreadyConnectedNames = new Set(
+				selectedOrg?.integrations.map((i) => i.githubAccountName) ?? []
+			);
+			const availableIntegrations = existingIntegrations.filter(
+				(i) => !alreadyConnectedNames.has(i.githubAccountName)
+			);
+
+			if (availableIntegrations.length > 0) {
+				tui.newline();
+
+				// Build checkbox choices
+				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 connect a new account'));
+				tui.newline();
+
+				const selectResponse = await enquirer.prompt<{ integrationIds: string[] }>({
+					type: 'multiselect',
+					name: 'integrationIds',
+					message: 'Select GitHub accounts to connect',
+					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(', ');
+
+					// Confirm
+					const confirmResponse = await enquirer.prompt<{ confirm: boolean }>({
+						type: 'confirm',
+						name: 'confirm',
+						message: `Connect ${tui.bold(accountNames)} to ${tui.bold(orgDisplay)}?`,
+						initial: true,
+					});
+
+					if (confirmResponse.confirm) {
+						await tui.spinner({
+							message: `Copying ${selectedIntegrations.length} GitHub connection${selectedIntegrations.length > 1 ? 's' : ''}...`,
+							clearOnSuccess: true,
+							callback: async () => {
+								for (const integration of selectedIntegrations) {
+									await copyGithubIntegration(apiClient, integration.orgId, orgId);
+								}
+							},
+						});
+
+						tui.newline();
+						tui.success(`GitHub connected to ${tui.bold(orgDisplay)}`);
+						tui.newline();
+						console.log(
+							'You can now link repositories to your projects for automatic deployments.'
+						);
+						return;
+					}
+				}
+			}
+
+			const startResult = await tui.spinner({
+				message: 'Getting GitHub authorization URL...',
+				clearOnSuccess: true,
+				callback: () => startGithubIntegration(apiClient, orgId),
+			});
+
+			if (!startResult) {
+				tui.error('Failed to get GitHub authorization URL');
+				return;
+			}
+
+			const { shortId } = startResult;
+			const apiBaseUrl = getAPIBaseURL(ctx.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, // 10 minutes
+				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 connected to ${tui.bold(orgDisplay)}`);
+				tui.newline();
+				console.log(
+					'You can now link repositories to your projects for automatic deployments.'
+				);
+			}
+		} catch (error) {
+			// Handle user cancellation (Ctrl+C) - enquirer throws empty string or Error with empty message
+			const isCancel =
+				error === '' ||
+				(error instanceof Error &&
+					(error.message === '' || error.message === 'User cancelled'));
+
+			if (isCancel) {
+				tui.newline();
+				tui.info('Cancelled');
+				return;
+			}
+
+			logger.trace(error);
+			logger.fatal('GitHub integration failed: %s', error, ErrorCode.INTEGRATION_FAILED);
+		}
+	},
+});