@agentuity/cli 0.0.110 → 0.0.112

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

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

@@ -556,7 +556,7 @@ export const InitialProjectConfigSchema = z.intersection(
 type InitialProjectConfig = z.infer<typeof InitialProjectConfigSchema>;
 
 export async function createProjectConfig(dir: string, config: InitialProjectConfig) {
-	const { sdkKey, ...sanitizedConfig } = config;
+	const { sdkKey, skipGitSetup: _skipGitSetup, ...sanitizedConfig } = config;
 
 	// generate the project config
 	const configPath = join(dir, 'agentuity.json');
@@ -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/log-collector.ts

@@ -0,0 +1,77 @@
+/**
+ * Log Collector for clean build logs
+ *
+ * Provides a mechanism to collect clean, non-animated log output
+ * for streaming to external services (like Pulse) while keeping
+ * animated TUI output for the user's terminal.
+ *
+ * Usage:
+ * - Set AGENTUITY_CLEAN_LOGS_FILE env var to a file path
+ * - TUI components call appendLog() for final state messages
+ * - Logs are written to the file for the parent process to read
+ */
+
+import { appendFileSync, writeFileSync } from 'node:fs';
+
+/**
+ * Get the clean logs file path from environment
+ */
+function getCleanLogsFile(): string | undefined {
+	return process.env.AGENTUITY_CLEAN_LOGS_FILE;
+}
+
+/**
+ * Disable log collection (called on write errors to prevent repeated failures)
+ */
+function disableLogCollection(error: unknown): void {
+	console.debug('Log collection disabled due to write error: %s', error);
+	delete process.env.AGENTUITY_CLEAN_LOGS_FILE;
+}
+
+/**
+ * Check if log collection is enabled (via environment variable)
+ */
+export function isLogCollectionEnabled(): boolean {
+	return !!getCleanLogsFile();
+}
+
+/**
+ * Initialize the clean logs file (clears any existing content)
+ */
+export function initCleanLogsFile(filePath: string): void {
+	try {
+		writeFileSync(filePath, '');
+		process.env.AGENTUITY_CLEAN_LOGS_FILE = filePath;
+	} catch (err) {
+		console.debug('Failed to initialize clean logs file: %s', err);
+	}
+}
+
+/**
+ * Append a clean log line (no ANSI codes, no animation)
+ * Only appends if collection is enabled
+ */
+export function appendLog(message: string): void {
+	const file = getCleanLogsFile();
+	if (file) {
+		try {
+			appendFileSync(file, message + '\n');
+		} catch (err) {
+			disableLogCollection(err);
+		}
+	}
+}
+
+/**
+ * Append multiple log lines
+ */
+export function appendLogs(messages: string[]): void {
+	const file = getCleanLogsFile();
+	if (file) {
+		try {
+			appendFileSync(file, messages.join('\n') + '\n');
+		} catch (err) {
+			disableLogCollection(err);
+		}
+	}
+}

package/src/output.ts

@@ -1,4 +1,5 @@
 import type { GlobalOptions } from './types';
+import { isTTYLike } from './tui';
 
 /**
  * Output formatting utilities for agent-friendly CLI
@@ -59,7 +60,7 @@ export function shouldDisableColors(options: GlobalOptions): boolean {
 		return false;
 	}
 	// auto mode - disable in JSON/quiet mode or non-TTY
-	return options.json === true || options.quiet === true || !process.stdout.isTTY;
+	return options.json === true || options.quiet === true || !isTTYLike();
 }
 
 /**

package/src/steps.ts

@@ -8,7 +8,8 @@
 import type { ColorScheme } from './terminal';
 import type { LogLevel } from './types';
 import { ValidationInputError, ValidationOutputError, type IssuesType } from '@agentuity/server';
-import { clearLastLines } from './tui';
+import { clearLastLines, isTTYLike } from './tui';
+import { appendLog, isLogCollectionEnabled } from './log-collector';
 
 // Spinner frames
 const FRAMES = ['◐', '◓', '◑', '◒'];
@@ -129,6 +130,38 @@ function renderStepLine(step: StepState, spinner?: string): string {
 	}
 }
 
+/**
+ * Generate a clean log line for a completed step (no ANSI, no animation)
+ */
+function getCleanStepLog(step: StepState): string {
+	if (step.status === 'success') {
+		return `${ICONS.success} ${step.label}`;
+	} else if (step.status === 'skipped') {
+		const reason = step.skipReason ? ` (${step.skipReason})` : '';
+		return `${ICONS.skipped} ${step.label}${reason}`;
+	} else if (step.status === 'error') {
+		const error = step.errorMessage ? `: ${step.errorMessage}` : '';
+		return `${ICONS.error} ${step.label}${error}`;
+	}
+	return `${ICONS.pending} ${step.label}`;
+}
+
+/**
+ * Emit clean log for a completed step if log collection is enabled
+ */
+function emitCleanStepLog(step: StepState): void {
+	if (!isLogCollectionEnabled()) return;
+
+	appendLog(getCleanStepLog(step));
+
+	// Also emit any output lines
+	if (step.output && step.output.length > 0) {
+		for (const line of step.output) {
+			appendLog(`  ${line}`);
+		}
+	}
+}
+
 /**
  * Render all steps from state, including output boxes
  * Returns the rendered output and total line count
@@ -212,7 +245,7 @@ function enablePauseResume(
  * Returns resume function
  */
 export function pauseStepUI(clear = false): () => void {
-	if (!process.stdout.isTTY || !getTotalLinesFn) {
+	if (!isTTYLike() || !getTotalLinesFn) {
 		return () => {}; // No-op if not TTY or not in step context
 	}
 
@@ -466,6 +499,9 @@ async function runStepsTUI(steps: Step[]): Promise<void> {
 				activeInterval = null;
 			}
 
+			// Emit clean log for this step (for external log collection)
+			emitCleanStepLog(stepState);
+
 			// Final render with outcome
 			stepState.progress = undefined;
 			const finalRender = renderAllSteps(state, -1);
@@ -529,6 +565,19 @@ async function runStepsPlain(steps: Step[]): Promise<void> {
 			};
 		}
 
+		// Build step state for clean log emission
+		const stepState: StepState = {
+			label: step.label,
+			status: outcome.status,
+			output: outcome.output,
+			skipReason: outcome.status === 'skipped' ? outcome.reason : undefined,
+			errorMessage: outcome.status === 'error' ? outcome.message : undefined,
+			errorCause: outcome.status === 'error' ? outcome.cause : undefined,
+		};
+
+		// Emit clean log for this step
+		emitCleanStepLog(stepState);
+
 		// Print final state
 		if (outcome.status === 'success') {
 			console.log(`${greenColor}${ICONS.success}${COLORS.reset} ${step.label}`);
@@ -579,8 +628,7 @@ async function runStepsPlain(steps: Step[]): Promise<void> {
  * Run a series of steps with animated progress
  */
 export async function runSteps(steps: Step[], logLevel?: LogLevel): Promise<void> {
-	const useTUI =
-		process.stdout.isTTY && (!logLevel || ['info', 'warn', 'error'].includes(logLevel));
+	const useTUI = isTTYLike() && (!logLevel || ['info', 'warn', 'error'].includes(logLevel));
 
 	if (useTUI) {
 		await runStepsTUI(steps);