@agentuity/cli 1.0.13 → 1.0.15

package/src/cmd/git/status.ts

@@ -1,22 +1,28 @@
-import { createSubcommand } from '../../types';
-import * as tui from '../../tui';
+import { z } from 'zod';
 import { getCommand } from '../../command-prefix';
 import { ErrorCode } from '../../errors';
-import { getProjectGithubStatus, getGithubIntegrationStatus } from './api';
-import { z } from 'zod';
+import * as tui from '../../tui';
+import { createSubcommand } from '../../types';
+import { getGithubIntegrationStatus, getProjectGithubStatus } from './api';
 
 const StatusResponseSchema = z.object({
-	orgId: z.string().describe('Organization ID'),
-	connected: z.boolean().describe('Whether GitHub is connected to the org'),
-	integrations: z
+	connected: z.boolean().describe('Whether GitHub is connected'),
+	identity: z
+		.object({
+			githubUsername: z.string(),
+			githubEmail: z.string().optional(),
+		})
+		.nullable()
+		.describe('Connected GitHub identity'),
+	installations: z
 		.array(
 			z.object({
-				id: z.string(),
-				githubAccountName: z.string(),
-				githubAccountType: z.enum(['user', 'org']),
+				installationId: z.string(),
+				accountName: z.string(),
+				accountType: z.enum(['User', 'Organization']),
 			})
 		)
-		.describe('Connected GitHub accounts'),
+		.describe('GitHub App installations'),
 	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'),
@@ -50,11 +56,11 @@ export const statusSubcommand = createSubcommand({
 		const { logger, apiClient, project, options } = ctx;
 
 		try {
-			// Get org-level GitHub status
-			const orgStatus = await tui.spinner({
+			// Get user-level GitHub status
+			const githubStatus = await tui.spinner({
 				message: 'Checking GitHub connection...',
 				clearOnSuccess: true,
-				callback: () => getGithubIntegrationStatus(apiClient, project.orgId),
+				callback: () => getGithubIntegrationStatus(apiClient),
 			});
 
 			// Get project-level link status
@@ -65,12 +71,17 @@ export const statusSubcommand = createSubcommand({
 			});
 
 			const result = {
-				orgId: project.orgId,
-				connected: orgStatus.connected,
-				integrations: orgStatus.integrations.map((i) => ({
-					id: i.id,
-					githubAccountName: i.githubAccountName,
-					githubAccountType: i.githubAccountType,
+				connected: githubStatus.connected,
+				identity: githubStatus.identity
+					? {
+							githubUsername: githubStatus.identity.githubUsername,
+							githubEmail: githubStatus.identity.githubEmail,
+						}
+					: null,
+				installations: githubStatus.installations.map((i) => ({
+					installationId: i.installationId,
+					accountName: i.accountName,
+					accountType: i.accountType,
 				})),
 				projectId: project.projectId,
 				linked: projectStatus.linked,
@@ -86,47 +97,51 @@ export const statusSubcommand = createSubcommand({
 			}
 
 			tui.newline();
-			console.log(tui.bold('GitHub Status'));
+			tui.output(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`
+			// GitHub identity status
+			if (githubStatus.connected && githubStatus.identity) {
+				tui.output(
+					`${tui.bold('GitHub:')} ${tui.colorSuccess('✓')} Connected as ${tui.bold(githubStatus.identity.githubUsername)}`
 				);
-				for (const integration of orgStatus.integrations) {
-					const typeLabel = integration.githubAccountType === 'org' ? 'org' : 'user';
-					console.log(`    - ${integration.githubAccountName} ${tui.muted(`(${typeLabel})`)}`);
+				if (githubStatus.installations.length > 0) {
+					tui.output(
+						`  ${githubStatus.installations.length} installation${githubStatus.installations.length > 1 ? 's' : ''}`
+					);
+					for (const installation of githubStatus.installations) {
+						const typeLabel = installation.accountType === 'Organization' ? 'org' : 'user';
+						tui.output(`    - ${installation.accountName} ${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.output(`${tui.bold('GitHub:')} ${tui.colorError('✗')} No GitHub account connected`);
+				tui.output(
+					tui.muted(`    Run ${tui.bold('agentuity git identity connect')} to connect one`)
 				);
 			}
 
 			tui.newline();
 
 			// Project status
-			console.log(`${tui.bold('Project:')} ${project.projectId}`);
+			tui.output(`${tui.bold('Project:')} ${project.projectId}`);
 			if (projectStatus.linked) {
-				console.log(
+				tui.output(
 					`  ${tui.colorSuccess('✓')} Linked to ${tui.bold(projectStatus.repoFullName ?? '<unknown repository>')}`
 				);
-				console.log(`    Branch: ${projectStatus.branch}`);
+				tui.output(`    Branch: ${projectStatus.branch}`);
 				if (projectStatus.directory) {
-					console.log(`    Directory: ${projectStatus.directory}`);
+					tui.output(`    Directory: ${projectStatus.directory}`);
 				}
-				console.log(
+				tui.output(
 					`    Auto-deploy: ${projectStatus.autoDeploy ? tui.colorSuccess('enabled') : tui.muted('disabled')}`
 				);
-				console.log(
+				tui.output(
 					`    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.output(`  ${tui.muted('○')} Not linked to a repository`);
+				tui.output(tui.muted(`    Run ${tui.bold('agentuity git link')} to link one`));
 			}
 
 			tui.newline();

package/src/cmd/upgrade/npm-availability.ts

@@ -1,15 +1,10 @@
 /**
  * npm registry availability checking utilities.
- * Used to verify a version is available via bun's resolver before attempting upgrade.
+ * Used to verify a version is available on npm before attempting upgrade.
  */
 
-import { tmpdir } from 'node:os';
-
 const PACKAGE_SPEC = '@agentuity/cli';
 
-/** Default timeout for `bun info` subprocess calls (10 seconds) */
-const BUN_INFO_TIMEOUT_MS = 10_000;
-
 /** Default timeout for install (`bun add -g`) subprocess calls (30 seconds) */
 const INSTALL_TIMEOUT_MS = 30_000;
 
@@ -89,28 +84,24 @@ async function withTimeout<T>(
 }
 
 /**
- * Check if a specific version of @agentuity/cli is resolvable by bun.
- * Uses `bun info` to verify bun's own resolver/CDN can see the version,
- * which avoids the race where npm registry returns 200 but bun's CDN
- * has not yet propagated the version.
+ * Check if a specific version of @agentuity/cli is available on the npm registry.
  *
  * @param version - Version to check (with or without 'v' prefix)
  * @returns true if version is available, false otherwise
  */
-export async function isVersionAvailableOnNpm(version: string): Promise<boolean> {
+export async function isVersionAvailableOnNpm(
+	version: string,
+	options?: { timeoutMs?: number }
+): Promise<boolean> {
 	const normalizedVersion = version.replace(/^v/, '');
+	const timeoutMs = options?.timeoutMs ?? 10_000;
 	try {
-		const result = await spawnWithTimeout(
-			['bun', 'info', `${PACKAGE_SPEC}@${normalizedVersion}`, '--json'],
-			{ cwd: tmpdir(), timeout: BUN_INFO_TIMEOUT_MS }
+		const response = await fetch(
+			`https://registry.npmjs.org/${PACKAGE_SPEC}/${normalizedVersion}`,
+			{ signal: AbortSignal.timeout(timeoutMs) }
 		);
-		if (result.exitCode !== 0) {
-			return false;
-		}
-		const info = JSON.parse(result.stdout.toString());
-		if (info.error) {
-			return false;
-		}
+		if (!response.ok) return false;
+		const info = (await response.json()) as { version?: string };
 		return info.version === normalizedVersion;
 	} catch {
 		return false;
@@ -118,14 +109,14 @@ export async function isVersionAvailableOnNpm(version: string): Promise<boolean>
 }
 
 /**
- * Quick check if a version is available via bun's resolver.
+ * Quick check if a version is available on npm.
  * Used for implicit version checks (auto-upgrade flow).
  *
  * @param version - Version to check (with or without 'v' prefix)
  * @returns true if version is available, false if unavailable or error
  */
 export async function isVersionAvailableOnNpmQuick(version: string): Promise<boolean> {
-	return isVersionAvailableOnNpm(version);
+	return isVersionAvailableOnNpm(version, { timeoutMs: 1_000 });
 }
 
 export interface WaitForNpmOptions {

package/src/config.ts

@@ -19,6 +19,7 @@ import {
 	deleteAuthFromKeychain,
 } from './keychain';
 import { clearProfileCache } from './cache';
+import { readEnvFile, writeEnvFile } from './env-util';
 
 export const defaultProfileName = 'production';
 
@@ -634,12 +635,20 @@ export async function createProjectConfig(dir: string, config: InitialProjectCon
 	};
 	await Bun.write(configPath, JSON.stringify(configData, null, 2) + '\n');
 
-	// generate the .env file with initial secret
+	// generate or update the .env file with SDK key
 	const envPath = join(dir, '.env');
-	const comment =
-		'# AGENTUITY_SDK_KEY is a sensitive value and should not be committed to version control.';
-	const content = `${comment}\nAGENTUITY_SDK_KEY=${sdkKey}\n`;
-	await Bun.write(envPath, content);
+	const envFile = Bun.file(envPath);
+	if (await envFile.exists()) {
+		// Preserve existing .env content, just update SDK key
+		const existing = await readEnvFile(envPath);
+		existing.AGENTUITY_SDK_KEY = sdkKey;
+		await writeEnvFile(envPath, existing, { preserveExisting: false });
+	} else {
+		const comment =
+			'# AGENTUITY_SDK_KEY is a sensitive value and should not be committed to version control.';
+		const content = `${comment}\nAGENTUITY_SDK_KEY=${sdkKey}\n`;
+		await Bun.write(envPath, content);
+	}
 	await chmod(envPath, 0o600);
 
 	// generate the vscode settings (only if they don't already exist)

package/src/utils/detectSubagent.ts

@@ -1,3 +1,5 @@
+import { toForwardSlash } from './normalize-path';
+
 /**
  * Detects if a file path represents a subagent based on path structure.
  *
@@ -19,6 +21,9 @@ export function detectSubagent(
 		normalizedPath = normalizedPath.replace(srcDir, '');
 	}
 
+	// Normalize path separators for cross-platform compatibility
+	normalizedPath = toForwardSlash(normalizedPath);
+
 	// Strip leading './' and split into parts, filtering out empty segments
 	const pathParts = normalizedPath.replace(/^\.\//, '').split('/').filter(Boolean);
 

package/src/utils/normalize-path.ts

@@ -0,0 +1,12 @@
+/**
+ * Normalize path separators to forward slashes for cross-platform compatibility.
+ *
+ * On Windows, Node.js path functions (relative, resolve, join) return backslashes.
+ * JavaScript import paths, zip entry names, and remote file paths must use forward slashes.
+ *
+ * @param p - The path to normalize
+ * @returns The path with all backslashes replaced by forward slashes
+ */
+export function toForwardSlash(p: string): string {
+	return p.replace(/\\/g, '/');
+}

package/src/utils/zip.ts

@@ -1,6 +1,7 @@
 import { relative } from 'node:path';
 import { Glob } from 'bun';
 import AdmZip from 'adm-zip';
+import { toForwardSlash } from './normalize-path';
 
 interface Options {
 	progress?: (val: number) => void;
@@ -15,7 +16,7 @@ export async function zipDir(dir: string, outdir: string, options?: Options) {
 	const total = files.length;
 	let count = 0;
 	for (const file of files) {
-		const rel = relative(dir, file);
+		const rel = toForwardSlash(relative(dir, file));
 		let skip = false;
 		if (options?.filter) {
 			if (!options.filter(file, rel)) {