@agentuity/cli 0.0.110 → 0.0.111

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

@@ -0,0 +1,149 @@
+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 {
+	getGithubIntegrationStatus,
+	disconnectGithubIntegration,
+	type GithubIntegration,
+} from '../api';
+
+export const disconnectSubcommand = createSubcommand({
+	name: 'disconnect',
+	description: 'Disconnect a GitHub account from your organization',
+	tags: ['mutating', 'destructive', 'slow'],
+	idempotent: false,
+	requires: { auth: true, apiClient: true },
+	examples: [
+		{
+			command: getCommand('integration github disconnect'),
+			description: 'Disconnect a GitHub account from 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;
+				},
+			});
+
+			// 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 (allIntegrations.length === 0) {
+				tui.newline();
+				tui.info('No GitHub accounts are connected.');
+				return;
+			}
+
+			// 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}`,
+			}));
+
+			// Show picker
+			const response = await enquirer.prompt<{ selection: string }>({
+				type: 'select',
+				name: 'selection',
+				message: 'Select a GitHub account to disconnect',
+				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 displayName = selected
+				? `${tui.bold(selected.integration.githubAccountName)} from ${tui.bold(selected.orgName)}`
+				: response.selection;
+
+			// Confirm
+			const confirmed = await tui.confirm(`Are you sure you want to disconnect ${displayName}?`);
+
+			if (!confirmed) {
+				tui.newline();
+				tui.info('Cancelled');
+				return;
+			}
+
+			await tui.spinner({
+				message: 'Disconnecting GitHub...',
+				clearOnSuccess: true,
+				callback: () => disconnectGithubIntegration(apiClient, orgId, integrationId),
+			});
+
+			tui.newline();
+			tui.success(`Disconnected ${displayName}`);
+		} catch (error) {
+			// Handle user cancellation (Ctrl+C)
+			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 disconnect failed: %s', error, ErrorCode.INTEGRATION_FAILED);
+		}
+	},
+});

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

@@ -0,0 +1,21 @@
+import { createCommand } from '../../../types';
+import { getCommand } from '../../../command-prefix';
+import { connectSubcommand } from './connect';
+import { disconnectSubcommand } from './disconnect';
+
+export const githubCommand = createCommand({
+	name: 'github',
+	description: 'GitHub integration commands',
+	tags: ['requires-auth'],
+	examples: [
+		{
+			command: getCommand('integration github connect'),
+			description: 'Connect GitHub to your organization',
+		},
+		{
+			command: getCommand('integration github disconnect'),
+			description: 'Disconnect GitHub from your organization',
+		},
+	],
+	subcommands: [connectSubcommand, disconnectSubcommand],
+});

package/src/cmd/integration/index.ts

@@ -0,0 +1,16 @@
+import { createCommand } from '../../types';
+import { getCommand } from '../../command-prefix';
+import { githubCommand } from './github';
+
+export const command = createCommand({
+	name: 'integration',
+	description: 'Manage integrations with external services',
+	tags: ['requires-auth'],
+	examples: [
+		{
+			command: getCommand('integration github connect'),
+			description: 'Connect GitHub to your organization',
+		},
+	],
+	subcommands: [githubCommand],
+});

package/src/config.ts

@@ -596,6 +596,40 @@ export async function createProjectConfig(dir: string, config: InitialProjectCon
 	await Bun.write(join(vscodeDir, 'settings.json'), JSON.stringify(settings, null, 2));
 }
 
+export async function updateProjectConfig(
+	dir: string,
+	updates: Partial<z.infer<typeof ProjectSchema>>,
+	config?: Config | null
+): Promise<void> {
+	let configPath = join(dir, 'agentuity.json');
+
+	if (config?.name) {
+		const profileConfigPath = join(dir, `agentuity.${config.name}.json`);
+		if (await Bun.file(profileConfigPath).exists()) {
+			configPath = profileConfigPath;
+		}
+	}
+
+	const file = Bun.file(configPath);
+	if (!(await file.exists())) {
+		throw new Error(`Project config not found at ${configPath}`);
+	}
+
+	const text = await file.text();
+	const existing = JSON5.parse(text);
+	const updated = { ...existing, ...updates };
+
+	const result = ProjectSchema.safeParse(updated);
+	if (!result.success) {
+		const issues = result.error.issues
+			.map((i) => `${i.path.join('.') || 'root'}: ${i.message}`)
+			.join(', ');
+		throw new Error(`Invalid project config after update: ${issues}`);
+	}
+
+	await Bun.write(configPath, JSON.stringify(updated, null, 2) + '\n');
+}
+
 const BuildMetadataNotFoundError = StructuredError('BuildMetadataNotFoundError');
 
 export async function loadBuildMetadata(dir: string): Promise<BuildMetadata> {

package/src/errors.ts

@@ -72,6 +72,9 @@ export enum ErrorCode {
 
 	// Build failed error
 	BUILD_FAILED = 'BUILD_FAILED',
+
+	// Integration errors
+	INTEGRATION_FAILED = 'INTEGRATION_FAILED',
 }
 
 /**
@@ -129,6 +132,10 @@ export function getExitCode(errorCode: ErrorCode): ExitCode {
 		case ErrorCode.BUILD_FAILED:
 			return ExitCode.BUILD_FAILED;
 
+		// Integration errors
+		case ErrorCode.INTEGRATION_FAILED:
+			return ExitCode.NETWORK_ERROR;
+
 		// Resource conflicts and other errors
 		case ErrorCode.RESOURCE_ALREADY_EXISTS:
 		case ErrorCode.RESOURCE_CONFLICT:

package/src/types.ts

@@ -554,6 +554,10 @@ export const ProjectSchema = zod.object({
 	orgId: zod.string().describe('the organization id'),
 	region: zod.string().describe('the region identifier that the project is deployed into'),
 	deployment: DeploymentConfig.optional().describe('the deployment configuration'),
+	skipGitSetup: zod
+		.boolean()
+		.optional()
+		.describe('whether to skip the git integration setup prompt during deploy'),
 });
 
 export const BuildMetadataSchema = ServerBuildMetadataSchema;