@agentuity/cli 0.0.109 → 0.0.111

package/src/cmd/git/status.ts

@@ -0,0 +1,144 @@
+import { createSubcommand } from '../../types';
+import * as tui from '../../tui';
+import { getCommand } from '../../command-prefix';
+import { ErrorCode } from '../../errors';
+import { getProjectGithubStatus, getGithubIntegrationStatus } from '../integration/api';
+import { z } from 'zod';
+
+const StatusResponseSchema = z.object({
+	orgId: z.string().describe('Organization ID'),
+	connected: z.boolean().describe('Whether GitHub is connected to the org'),
+	integrations: z
+		.array(
+			z.object({
+				id: z.string(),
+				githubAccountName: z.string(),
+				githubAccountType: z.enum(['user', 'org']),
+			})
+		)
+		.describe('Connected GitHub accounts'),
+	projectId: z.string().describe('Project ID'),
+	linked: z.boolean().describe('Whether the project is linked to a repo'),
+	repoFullName: z.string().optional().describe('Full repository name'),
+	branch: z.string().optional().describe('Branch'),
+	directory: z.string().optional().describe('Directory'),
+	autoDeploy: z.boolean().optional().describe('Auto-deploy enabled'),
+	previewDeploy: z.boolean().optional().describe('Preview deploys enabled'),
+});
+
+export const statusSubcommand = createSubcommand({
+	name: 'status',
+	description: 'Show GitHub connection status for current project',
+	tags: ['read-only'],
+	idempotent: true,
+	requires: { auth: true, apiClient: true, project: true },
+	schema: {
+		response: StatusResponseSchema,
+	},
+	examples: [
+		{
+			command: getCommand('git status'),
+			description: 'Show GitHub status for current project',
+		},
+		{
+			command: getCommand('--json git status'),
+			description: 'Get status in JSON format',
+		},
+	],
+
+	async handler(ctx) {
+		const { logger, apiClient, project, options } = ctx;
+
+		try {
+			// Get org-level GitHub status
+			const orgStatus = await tui.spinner({
+				message: 'Checking GitHub connection...',
+				clearOnSuccess: true,
+				callback: () => getGithubIntegrationStatus(apiClient, project.orgId),
+			});
+
+			// Get project-level link status
+			const projectStatus = await tui.spinner({
+				message: 'Checking project status...',
+				clearOnSuccess: true,
+				callback: () => getProjectGithubStatus(apiClient, project.projectId),
+			});
+
+			const result = {
+				orgId: project.orgId,
+				connected: orgStatus.connected,
+				integrations: orgStatus.integrations.map((i) => ({
+					id: i.id,
+					githubAccountName: i.githubAccountName,
+					githubAccountType: i.githubAccountType,
+				})),
+				projectId: project.projectId,
+				linked: projectStatus.linked,
+				repoFullName: projectStatus.repoFullName,
+				branch: projectStatus.branch,
+				directory: projectStatus.directory,
+				autoDeploy: projectStatus.autoDeploy,
+				previewDeploy: projectStatus.previewDeploy,
+			};
+
+			if (options.json) {
+				return result;
+			}
+
+			tui.newline();
+			console.log(tui.bold('GitHub Status'));
+			tui.newline();
+
+			// Organization status
+			console.log(`${tui.bold('Organization:')} ${project.orgId}`);
+			if (orgStatus.connected && orgStatus.integrations.length > 0) {
+				console.log(
+					`  ${tui.colorSuccess('✓')} ${orgStatus.integrations.length} GitHub account${orgStatus.integrations.length > 1 ? 's' : ''} connected`
+				);
+				for (const integration of orgStatus.integrations) {
+					const typeLabel = integration.githubAccountType === 'org' ? 'org' : 'user';
+					console.log(`    - ${integration.githubAccountName} ${tui.muted(`(${typeLabel})`)}`);
+				}
+			} else {
+				console.log(`  ${tui.colorError('✗')} No GitHub accounts connected`);
+				console.log(
+					tui.muted(`    Run ${tui.bold('agentuity git account add')} to connect one`)
+				);
+			}
+
+			tui.newline();
+
+			// Project status
+			console.log(`${tui.bold('Project:')} ${project.projectId}`);
+			if (projectStatus.linked) {
+				console.log(
+					`  ${tui.colorSuccess('✓')} Linked to ${tui.bold(projectStatus.repoFullName ?? '<unknown repository>')}`
+				);
+				console.log(`    Branch: ${projectStatus.branch}`);
+				if (projectStatus.directory) {
+					console.log(`    Directory: ${projectStatus.directory}`);
+				}
+				console.log(
+					`    Auto-deploy: ${projectStatus.autoDeploy ? tui.colorSuccess('enabled') : tui.muted('disabled')}`
+				);
+				console.log(
+					`    Preview deploys: ${projectStatus.previewDeploy ? tui.colorSuccess('enabled') : tui.muted('disabled')}`
+				);
+			} else {
+				console.log(`  ${tui.muted('○')} Not linked to a repository`);
+				console.log(tui.muted(`    Run ${tui.bold('agentuity git link')} to link one`));
+			}
+
+			tui.newline();
+
+			return result;
+		} catch (error) {
+			logger.trace(error);
+			return logger.fatal(
+				'Failed to get GitHub status: %s',
+				error,
+				ErrorCode.INTEGRATION_FAILED
+			);
+		}
+	},
+});

package/src/cmd/git/unlink.ts

@@ -0,0 +1,117 @@
+import { createSubcommand } from '../../types';
+import * as tui from '../../tui';
+import { getCommand } from '../../command-prefix';
+import { ErrorCode } from '../../errors';
+import { getProjectGithubStatus, unlinkProjectFromRepo } from '../integration/api';
+import { z } from 'zod';
+
+const UnlinkOptionsSchema = z.object({
+	confirm: z.boolean().optional().describe('Skip confirmation prompt'),
+});
+
+const UnlinkResponseSchema = z.object({
+	unlinked: z.boolean().describe('Whether the project was unlinked'),
+	repoFullName: z.string().optional().describe('Repository that was unlinked'),
+});
+
+export const unlinkSubcommand = createSubcommand({
+	name: 'unlink',
+	description: 'Unlink a project from its GitHub repository',
+	tags: ['mutating', 'destructive'],
+	idempotent: false,
+	requires: { auth: true, apiClient: true, project: true },
+	schema: {
+		options: UnlinkOptionsSchema,
+		response: UnlinkResponseSchema,
+	},
+	examples: [
+		{
+			command: getCommand('git unlink'),
+			description: 'Unlink current project from GitHub',
+		},
+		{
+			command: getCommand('git unlink --confirm'),
+			description: 'Unlink without confirmation prompt',
+		},
+		{
+			command: getCommand('--json git unlink --confirm'),
+			description: 'Unlink and return JSON result',
+		},
+	],
+
+	async handler(ctx) {
+		const { logger, apiClient, project, opts, options } = ctx;
+
+		try {
+			// Check current status
+			const status = await tui.spinner({
+				message: 'Checking current status...',
+				clearOnSuccess: true,
+				callback: () => getProjectGithubStatus(apiClient, project.projectId),
+			});
+
+			if (!status.linked) {
+				if (!options.json) {
+					tui.newline();
+					tui.info('This project is not linked to a GitHub repository.');
+				}
+				return { unlinked: false };
+			}
+
+			if (!opts.confirm) {
+				tui.newline();
+				console.log(`Currently linked to: ${tui.bold(status.repoFullName ?? 'Unknown')}`);
+				console.log(`  Branch: ${status.branch ?? 'default'}`);
+				if (status.directory) {
+					console.log(`  Directory: ${status.directory}`);
+				}
+				console.log(`  Auto-deploy: ${status.autoDeploy ? 'enabled' : 'disabled'}`);
+				console.log(`  Preview deploys: ${status.previewDeploy ? 'enabled' : 'disabled'}`);
+				tui.newline();
+
+				const confirmed = await tui.confirm(
+					`Are you sure you want to unlink from ${tui.bold(status.repoFullName ?? 'this repository')}?`
+				);
+
+				if (!confirmed) {
+					tui.info('Cancelled');
+					return { unlinked: false };
+				}
+			}
+
+			await tui.spinner({
+				message: 'Unlinking repository...',
+				clearOnSuccess: true,
+				callback: () => unlinkProjectFromRepo(apiClient, project.projectId),
+			});
+
+			if (!options.json) {
+				tui.newline();
+				tui.success(`Unlinked from ${tui.bold(status.repoFullName ?? 'repository')}`);
+				tui.newline();
+				console.log('Automatic deployments have been disabled for this project.');
+			}
+
+			return { unlinked: true, repoFullName: status.repoFullName };
+		} catch (error) {
+			// Handle user cancellation
+			const isCancel =
+				error === '' ||
+				(error instanceof Error &&
+					(error.message === '' || error.message === 'User cancelled'));
+
+			if (isCancel) {
+				tui.newline();
+				tui.info('Cancelled');
+				return { unlinked: false };
+			}
+
+			logger.trace(error);
+			return logger.fatal(
+				'Failed to unlink repository: %s',
+				error,
+				ErrorCode.INTEGRATION_FAILED
+			);
+		}
+	},
+});

package/src/cmd/index.ts

@@ -9,7 +9,9 @@ export async function discoverCommands(): Promise<CommandDefinition[]> {
 		import('./build').then((m) => m.command),
 		import('./cloud').then((m) => m.command),
 		import('./dev').then((m) => m.command),
+		import('./git').then((m) => m.gitCommand),
 		import('./help').then((m) => m.command),
+		import('./integration').then((m) => m.command),
 		import('./profile').then((m) => m.command),
 		import('./project').then((m) => m.command),
 		import('./repl').then((m) => m.command),

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;
+}