@agentuity/cli 1.0.13 → 1.0.15

package/src/cmd/cloud/env/set.ts

@@ -3,8 +3,6 @@ import { createSubcommand } from '../../../types';
 import * as tui from '../../../tui';
 import { projectEnvUpdate, orgEnvUpdate } from '@agentuity/server';
 import {
-	findExistingEnvFile,
-	writeEnvFile,
 	looksLikeSecret,
 	isReservedAgentuityKey,
 	isPublicVarKey,
@@ -75,10 +73,6 @@ function parseEnvArgs(rawArgs: string[]): ParsedEnvPair[] {
 const EnvSetResponseSchema = z.object({
 	success: z.boolean().describe('Whether the operation succeeded'),
 	keys: z.array(z.string()).describe('Environment variable keys that were set'),
-	path: z
-		.string()
-		.optional()
-		.describe('Local file path where env vars were saved (project scope only)'),
 	secretKeys: z.array(z.string()).describe('Keys that were stored as secrets'),
 	envKeys: z.array(z.string()).describe('Keys that were stored as env vars'),
 	scope: z.enum(['project', 'org']).describe('The scope where the variables were set'),
@@ -134,7 +128,7 @@ export const setSubcommand = createSubcommand({
 	},
 
 	async handler(ctx) {
-		const { args: cmdArgs, opts, apiClient, project, projectDir, config } = ctx;
+		const { args: cmdArgs, opts, apiClient, project, config } = ctx;
 		const useOrgScope = isOrgScope(opts?.org);
 		const forceSecret = opts?.secret ?? false;
 
@@ -262,26 +256,13 @@ export const setSubcommand = createSubcommand({
 				}
 			);
 
-			// Update local .env file only if we have a project directory
-			let envFilePath: string | undefined;
-			if (projectDir) {
-				envFilePath = await findExistingEnvFile(projectDir);
-				const allPairsForLocal: Record<string, string> = {
-					...envPairs,
-					...secretPairs,
-				};
-				await writeEnvFile(envFilePath, allPairsForLocal);
-			}
-
-			const locationMsg = envFilePath ? ` (cloud + ${envFilePath})` : ' (cloud only)';
 			tui.success(
-				`Variable${totalCount !== 1 ? 's' : ''} set successfully: ${allKeys.join(', ')}${secretSuffix}${locationMsg}`
+				`Variable${totalCount !== 1 ? 's' : ''} set successfully: ${allKeys.join(', ')}${secretSuffix}`
 			);
 
 			return {
 				success: true,
 				keys: allKeys,
-				path: envFilePath,
 				secretKeys: secretKeysList,
 				envKeys: envKeysList,
 				scope: 'project' as const,

package/src/cmd/cloud/sandbox/cp.ts

@@ -2,6 +2,7 @@ import { z } from 'zod';
 import { readFileSync, writeFileSync, mkdirSync, statSync, readdirSync } from 'node:fs';
 import { dirname, resolve, basename, join, relative } from 'node:path';
 import { createCommand } from '../../../types';
+import { toForwardSlash } from '../../../utils/normalize-path';
 import * as tui from '../../../tui';
 import { createSandboxClient } from './util';
 import { getCommand } from '../../../command-prefix';
@@ -265,7 +266,7 @@ async function uploadDirectory(
 		: effectiveRemotePath;
 
 	for (const filePath of allFiles) {
-		const relativePath = relative(localDir, filePath);
+		const relativePath = toForwardSlash(relative(localDir, filePath));
 		const targetPath = `${baseRemotePath}/${relativePath}`;
 		const buffer = readFileSync(filePath);
 		files.push({ path: targetPath, content: buffer });

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

@@ -1,119 +1,62 @@
-import { createSubcommand } from '../../../types';
-import type { Config } from '../../../types';
-import * as tui from '../../../tui';
-import { getCommand } from '../../../command-prefix';
-import { getAPIBaseURL } from '../../../api';
-import type { APIClient } from '../../../api';
-import { ErrorCode } from '../../../errors';
-import { listOrganizations } from '@agentuity/server';
-import enquirer from 'enquirer';
 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 {
-	startGithubIntegration,
-	pollForGithubIntegration,
 	getGithubIntegrationStatus,
-	getExistingGithubIntegrations,
-	copyGithubIntegration,
+	pollForGithubIntegration,
+	startGithubIntegration,
 } from '../api';
 
-export interface RunGitAccountConnectOptions {
+export interface RunGitAccountAddOptions {
 	apiClient: APIClient;
-	orgId: string;
-	orgName?: string;
 	logger: Logger;
 	config?: Config | null;
 }
 
-export interface RunGitAccountConnectResult {
-	connected: boolean;
+export interface RunGitAccountAddResult {
+	added: boolean;
 	cancelled?: boolean;
 }
 
-export async function runGitAccountConnect(
-	options: RunGitAccountConnectOptions
-): Promise<RunGitAccountConnectResult> {
-	const { apiClient, orgId, orgName, logger, config } = options;
-	const orgDisplay = orgName ?? orgId;
+export async function runGitAccountAdd(
+	options: RunGitAccountAddOptions
+): Promise<RunGitAccountAddResult> {
+	const { apiClient, logger, config } = options;
 
 	try {
-		const currentStatus = await getGithubIntegrationStatus(apiClient, orgId);
-		const initialCount = currentStatus.integrations?.length ?? 0;
-
-		const existingIntegrations = await tui.spinner({
-			message: 'Checking for existing GitHub connections...',
-			clearOnSuccess: true,
-			callback: () => getExistingGithubIntegrations(apiClient, orgId),
-		});
+		const currentStatus = await getGithubIntegrationStatus(apiClient);
 
-		const alreadyConnectedNames = new Set(
-			currentStatus.integrations?.map((i) => i.githubAccountName) ?? []
-		);
-		const availableIntegrations = existingIntegrations.filter(
-			(i) => !alreadyConnectedNames.has(i.githubAccountName)
-		);
-
-		if (availableIntegrations.length > 0) {
-			tui.newline();
-
-			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 add a new account'));
+		if (!currentStatus.connected || !currentStatus.identity) {
 			tui.newline();
+			tui.error(
+				`No GitHub identity connected. Run ${tui.bold('agentuity git identity connect')} first.`
+			);
+			return { added: false };
+		}
 
-			const selectResponse = await enquirer.prompt<{ integrationIds: string[] }>({
-				type: 'multiselect',
-				name: 'integrationIds',
-				message: 'Select GitHub accounts to add',
-				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(', ');
-
-				const confirmResponse = await enquirer.prompt<{ confirm: boolean }>({
-					type: 'confirm',
-					name: 'confirm',
-					message: `Add ${tui.bold(accountNames)} to ${tui.bold(orgDisplay)}?`,
-					initial: true,
-				});
-
-				if (confirmResponse.confirm) {
-					await tui.spinner({
-						message: `Adding ${selectedIntegrations.length} GitHub account${selectedIntegrations.length > 1 ? 's' : ''}...`,
-						clearOnSuccess: true,
-						callback: async () => {
-							for (const integration of selectedIntegrations) {
-								await copyGithubIntegration(apiClient, integration.orgId, orgId);
-							}
-						},
-					});
+		const initialCount = currentStatus.installations?.length ?? 0;
 
-					tui.newline();
-					tui.success(
-						`Added GitHub account${selectedIntegrations.length > 1 ? 's' : ''} to ${tui.bold(orgDisplay)}`
-					);
-					return { connected: true };
-				}
-			}
-		}
+		tui.newline();
+		tui.info(
+			`Connected as ${tui.bold(currentStatus.identity.githubUsername)}. Opening GitHub to install the app on a new account...`
+		);
+		tui.newline();
 
 		const startResult = await tui.spinner({
-			message: 'Getting GitHub authorization URL...',
+			message: 'Getting GitHub installation URL...',
 			clearOnSuccess: true,
-			callback: () => startGithubIntegration(apiClient, orgId),
+			callback: () => startGithubIntegration(apiClient),
 		});
 
 		if (!startResult) {
-			tui.error('Failed to start GitHub authorization');
-			return { connected: false };
+			tui.error('Failed to start GitHub installation flow');
+			return { added: false };
 		}
 
 		const { shortId } = startResult;
@@ -124,19 +67,19 @@ export async function runGitAccountConnect(
 
 		tui.newline();
 		if (copied) {
-			console.log('GitHub authorization URL copied to clipboard! Open it in your browser:');
+			tui.output('GitHub installation URL copied to clipboard! Open it in your browser:');
 		} else {
-			console.log('Open this URL in your browser to authorize GitHub access:');
+			tui.output('Open this URL in your browser to install the GitHub App:');
 		}
 		tui.newline();
-		console.log(`  ${tui.link(url)}`);
+		tui.output(`  ${tui.link(url)}`);
 		tui.newline();
-		console.log(tui.muted('Press Enter to open in your browser, or Ctrl+C to cancel'));
+		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',
+			message: 'Waiting for GitHub App installation',
 			timeoutMs: 600000,
 			clearOnSuccess: true,
 			onEnterPress: () => {
@@ -152,17 +95,17 @@ export async function runGitAccountConnect(
 				}
 			},
 			callback: async () => {
-				return await pollForGithubIntegration(apiClient, orgId, initialCount);
+				return await pollForGithubIntegration(apiClient, initialCount);
 			},
 		});
 
 		tui.newline();
 		if (result.connected) {
-			tui.success(`GitHub account added to ${tui.bold(orgDisplay)}`);
-			return { connected: true };
+			tui.success('GitHub App installed on new account');
+			return { added: true };
 		}
 
-		return { connected: false };
+		return { added: false };
 	} catch (error) {
 		const isCancel =
 			error === '' ||
@@ -171,7 +114,7 @@ export async function runGitAccountConnect(
 		if (isCancel) {
 			tui.newline();
 			tui.info('Cancelled');
-			return { connected: false, cancelled: true };
+			return { added: false, cancelled: true };
 		}
 
 		logger.trace(error);
@@ -179,18 +122,15 @@ export async function runGitAccountConnect(
 	}
 }
 
-const AddOptionsSchema = z.object({
-	org: z.string().optional().describe('Organization ID to add the account to'),
-});
+const AddOptionsSchema = z.object({});
 
 const AddResponseSchema = z.object({
-	connected: z.boolean().describe('Whether the account was connected'),
-	orgId: z.string().optional().describe('Organization ID'),
+	added: z.boolean().describe('Whether the installation was added'),
 });
 
 export const addSubcommand = createSubcommand({
 	name: 'add',
-	description: 'Add a GitHub account to your organization',
+	description: 'Install the GitHub App on a new account or organization',
 	tags: ['mutating', 'creates-resource', 'slow', 'api-intensive'],
 	idempotent: false,
 	requires: { auth: true, apiClient: true },
@@ -201,100 +141,21 @@ export const addSubcommand = createSubcommand({
 	examples: [
 		{
 			command: getCommand('git account add'),
-			description: 'Add a GitHub account to your organization',
-		},
-		{
-			command: getCommand('git account add --org org_abc123'),
-			description: 'Add to a specific organization',
+			description: 'Install the GitHub App on a new account',
 		},
 	],
 
 	async handler(ctx) {
-		const { logger, apiClient, config, opts } = ctx;
+		const { logger, apiClient, config } = ctx;
 
 		try {
-			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');
-			}
-
-			let orgId = opts.org;
-			let selectedOrg: (typeof orgs)[0] | undefined;
-
-			if (orgId) {
-				selectedOrg = orgs.find((o) => o.id === orgId);
-				if (!selectedOrg) {
-					tui.fatal(`Organization ${orgId} not found`);
-				}
-			} else {
-				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;
-					},
-				});
-
-				const sortedOrgs = [...orgStatuses].sort((a, b) => a.name.localeCompare(b.name));
-
-				const firstOrg = orgs[0];
-				if (orgs.length === 1 && firstOrg) {
-					orgId = firstOrg.id;
-					selectedOrg = firstOrg;
-				} else {
-					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,
-						};
-					});
-
-					const response = await enquirer.prompt<{ orgName: string }>({
-						type: 'select',
-						name: 'orgName',
-						message: 'Select an organization',
-						choices,
-						result(name: string) {
-							// @ts-expect-error - this.map exists at runtime
-							return this.map(name)[name];
-						},
-					});
-
-					orgId = response.orgName;
-					selectedOrg = sortedOrgs.find((o) => o.id === orgId);
-				}
-			}
-
-			const result = await runGitAccountConnect({
+			const result = await runGitAccountAdd({
 				apiClient,
-				orgId: orgId!,
-				orgName: selectedOrg?.name,
 				logger,
 				config,
 			});
 
-			return { connected: result.connected, orgId };
+			return { added: result.added };
 		} catch (error) {
 			const isCancel =
 				error === '' ||
@@ -304,7 +165,7 @@ export const addSubcommand = createSubcommand({
 			if (isCancel) {
 				tui.newline();
 				tui.info('Cancelled');
-				return { connected: false };
+				return { added: false };
 			}
 
 			logger.trace(error);

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

@@ -1,12 +1,10 @@
 import { createCommand } from '../../../types';
 import { addSubcommand } from './add';
-import { removeSubcommand } from './remove';
 import { listSubcommand } from './list';
+import { removeSubcommand } from './remove';
 
 export const accountCommand = createCommand({
 	name: 'account',
-	description: 'Manage GitHub accounts connected to your organization',
-	subcommands: [addSubcommand, removeSubcommand, listSubcommand],
+	description: 'Manage GitHub App installations',
+	subcommands: [addSubcommand, listSubcommand, removeSubcommand],
 });
-
-export default accountCommand;

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

@@ -1,28 +1,23 @@
-import { createSubcommand } from '../../../types';
-import * as tui from '../../../tui';
+import { z } from 'zod';
 import { getCommand } from '../../../command-prefix';
 import { ErrorCode } from '../../../errors';
-import { listOrganizations } from '@agentuity/server';
+import * as tui from '../../../tui';
+import { createSubcommand } from '../../../types';
 import { getGithubIntegrationStatus } from '../api';
-import { z } from 'zod';
 
-const ListResponseSchema = z.array(
-	z.object({
-		orgId: z.string().describe('Organization ID'),
-		orgName: z.string().describe('Organization name'),
-		integrations: z.array(
-			z.object({
-				id: z.string().describe('Integration ID'),
-				githubAccountName: z.string().describe('GitHub account name'),
-				githubAccountType: z.enum(['user', 'org']).describe('Account type'),
-			})
-		),
-	})
-);
+const ListResponseSchema = z.object({
+	installations: z.array(
+		z.object({
+			installationId: z.string().describe('Installation ID'),
+			accountName: z.string().describe('GitHub account name'),
+			accountType: z.enum(['User', 'Organization']).describe('Account type'),
+		})
+	),
+});
 
 export const listSubcommand = createSubcommand({
 	name: 'list',
-	description: 'List GitHub accounts connected to your organizations',
+	description: 'List GitHub App installations',
 	aliases: ['ls'],
 	tags: ['read-only'],
 	idempotent: true,
@@ -33,11 +28,11 @@ export const listSubcommand = createSubcommand({
 	examples: [
 		{
 			command: getCommand('git account list'),
-			description: 'List all connected GitHub accounts',
+			description: 'List GitHub App installations',
 		},
 		{
 			command: getCommand('--json git account list'),
-			description: 'List accounts in JSON format',
+			description: 'List installations in JSON format',
 		},
 	],
 
@@ -45,92 +40,66 @@ export const listSubcommand = createSubcommand({
 		const { logger, apiClient, options } = ctx;
 
 		try {
-			// Fetch organizations
-			const orgs = await tui.spinner({
-				message: 'Fetching organizations...',
+			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;
-				},
-			});
-
-			// Sort orgs alphabetically
-			const sortedOrgs = [...orgStatuses].sort((a, b) => a.name.localeCompare(b.name));
-
-			const result = sortedOrgs.map((org) => ({
-				orgId: org.id,
-				orgName: org.name,
-				integrations: org.integrations.map((i) => ({
-					id: i.id,
-					githubAccountName: i.githubAccountName,
-					githubAccountType: i.githubAccountType,
+			const result = {
+				installations: status.installations.map((i) => ({
+					installationId: i.installationId,
+					accountName: i.accountName,
+					accountType: i.accountType,
 				})),
-			}));
+			};
 
 			if (options.json) {
 				return result;
 			}
 
 			tui.newline();
-			console.log(tui.bold('GitHub Accounts'));
-			tui.newline();
-
-			let totalCount = 0;
 
-			for (const org of sortedOrgs) {
-				if (org.integrations.length === 0) {
-					console.log(`  ${org.name} ${tui.muted('(no accounts connected)')}`);
-				} else {
-					console.log(`  ${org.name}`);
-					for (const integration of org.integrations) {
-						const typeLabel = integration.githubAccountType === 'org' ? 'org' : 'user';
-						console.log(
-							`    ${tui.colorSuccess('✓')} ${integration.githubAccountName} ${tui.muted(`(${typeLabel})`)}`
-						);
-						totalCount++;
-					}
-				}
+			if (!status.connected || !status.identity) {
+				tui.output(
+					tui.muted(
+						`No GitHub identity connected. Run ${tui.bold('agentuity git identity connect')} to connect one.`
+					)
+				);
+				tui.newline();
+				return result;
 			}
 
+			tui.output(tui.bold('GitHub App Installations'));
 			tui.newline();
-			if (totalCount === 0) {
-				console.log(
+
+			if (status.installations.length === 0) {
+				tui.output(
 					tui.muted(
-						`No GitHub accounts connected. Run ${tui.bold('agentuity git account add')} to add one.`
+						`No installations found. Run ${tui.bold('agentuity git account add')} to install the GitHub App.`
 					)
 				);
 			} else {
-				console.log(
-					tui.muted(`${totalCount} GitHub account${totalCount > 1 ? 's' : ''} connected`)
-				);
+				for (const installation of status.installations) {
+					const typeLabel = installation.accountType === 'Organization' ? 'org' : 'user';
+					tui.output(
+						`  ${tui.colorSuccess('✓')} ${installation.accountName} ${tui.muted(`(${typeLabel})`)}`
+					);
+				}
 			}
 
+			tui.newline();
+			tui.output(
+				tui.muted(
+					`${status.installations.length} installation${status.installations.length !== 1 ? 's' : ''}`
+				)
+			);
+
 			return result;
 		} catch (error) {
 			logger.trace(error);
 			return logger.fatal(
-				'Failed to list GitHub accounts: %s',
+				'Failed to list GitHub installations: %s',
 				error,
 				ErrorCode.INTEGRATION_FAILED
 			);