@agentuity/cli 0.0.33 → 0.0.41

package/src/api.ts

@@ -1,24 +1,17 @@
 /**
- * API Client for Agentuity Platform
+ * CLI-specific API client wrapper
  *
- * Handles HTTP requests to the API with automatic error parsing and User-Agent headers.
- *
- * Error handling:
- * - UPGRADE_REQUIRED (409): Throws UpgradeRequiredError
- * - Other errors: Throws Error with API message or status text
- *
- * See api-errors.md for full documentation.
+ * Re-exports from @agentuity/server with CLI-specific configuration
  */
 
 import type { Config } from './types';
 import { getVersion, getRevision } from './version';
-
-interface APIErrorResponse {
-	success: boolean;
-	code?: string;
-	message: string;
-	details?: Record<string, unknown>;
-}
+import {
+	APIClient as BaseAPIClient,
+	getAPIBaseURL as baseGetAPIBaseURL,
+	getAppBaseURL as baseGetAppBaseURL,
+	type APIClientConfig,
+} from '@agentuity/server';
 
 function getUserAgent(config?: Config | null): string {
 	// If we're skipping version check, send "dev" to signal the server to skip too
@@ -61,140 +54,36 @@ function shouldSkipVersionCheck(config?: Config | null): boolean {
 	return false;
 }
 
-export class UpgradeRequiredError extends Error {
-	constructor(message: string) {
-		super(message);
-		this.name = 'UpgradeRequiredError';
-	}
-}
-
-export class APIError extends Error {
-	constructor(
-		message: string,
-		public status: number,
-		public code?: string
-	) {
-		super(message);
-		this.name = 'APIError';
-	}
-}
-
-export class APIClient {
-	constructor(
-		private baseUrl: string,
-		private apiKey?: string,
-		private config?: Config | null
-	) {}
-
-	async request<T>(method: string, endpoint: string, body?: unknown): Promise<T> {
-		const url = `${this.baseUrl}${endpoint}`;
-		const headers: Record<string, string> = {
-			'Content-Type': 'application/json',
-			'User-Agent': getUserAgent(this.config),
+// CLI-specific wrapper around the base APIClient
+export class APIClient extends BaseAPIClient {
+	constructor(baseUrl: string, config?: Config | null);
+	constructor(baseUrl: string, apiKey: string, config?: Config | null);
+	constructor(baseUrl: string, apiKeyOrConfig?: string | Config | null, config?: Config | null) {
+		const clientConfig: APIClientConfig = {
+			skipVersionCheck: shouldSkipVersionCheck(
+				typeof apiKeyOrConfig === 'string' ? config : apiKeyOrConfig
+			),
+			userAgent: getUserAgent(typeof apiKeyOrConfig === 'string' ? config : apiKeyOrConfig),
 		};
 
-		if (this.apiKey) {
-			headers['Authorization'] = `Bearer ${this.apiKey}`;
-		}
-
-		const response = await fetch(url, {
-			method,
-			headers,
-			body: body ? JSON.stringify(body) : undefined,
-		});
-
-		if (!response.ok) {
-			const responseBody = await response.text();
-
-			// Try to parse error response
-			let errorData: APIErrorResponse | null = null;
-			try {
-				errorData = JSON.parse(responseBody) as APIErrorResponse;
-			} catch {
-				// Not JSON, ignore
-			}
-
-			if (process.env.DEBUG) {
-				// Sanitize headers to avoid leaking API keys
-				const sanitizedHeaders = { ...headers };
-				for (const key in sanitizedHeaders) {
-					if (key.toLowerCase() === 'authorization') {
-						sanitizedHeaders[key] = 'REDACTED';
-					}
-				}
-
-				console.error('API Error Details:');
-				console.error('  URL:', url);
-				console.error('  Method:', method);
-				console.error('  Status:', response.status, response.statusText);
-				console.error('  Headers:', JSON.stringify(sanitizedHeaders, null, 2));
-				console.error('  Response:', responseBody);
+		if (typeof apiKeyOrConfig === 'string') {
+			super(baseUrl, apiKeyOrConfig, clientConfig);
+		} else {
+			if (apiKeyOrConfig?.auth?.api_key) {
+				super(baseUrl, apiKeyOrConfig.auth.api_key, clientConfig);
+			} else {
+				super(baseUrl, clientConfig);
 			}
-
-			// Check for UPGRADE_REQUIRED error
-			if (errorData?.code === 'UPGRADE_REQUIRED') {
-				// Skip version check in development
-				if (shouldSkipVersionCheck(this.config)) {
-					if (process.env.DEBUG) {
-						console.error(
-							'[DEBUG] Skipping version check (flag/env/config override or dev mode)'
-						);
-					}
-					// Continue as if there was no error - the server should still process the request
-					// but we'll throw a different error since we can't continue with a 409
-					throw new Error('Version check skipped, but request failed. Try upgrading the CLI.');
-				}
-
-				throw new UpgradeRequiredError(
-					errorData.message || 'Please upgrade to the latest version of the CLI'
-				);
-			}
-
-			// Throw with message from API if available
-			if (errorData?.message) {
-				throw new APIError(errorData.message, response.status, errorData.code);
-			}
-
-			throw new APIError(
-				`API error: ${response.status} ${response.statusText}`,
-				response.status
-			);
-		}
-
-		// Successful response; handle empty bodies (e.g., 204 No Content)
-		if (response.status === 204) {
-			return undefined as T;
 		}
-		const contentLength = response.headers.get('content-length');
-		if (contentLength === '0') {
-			return undefined as T;
-		}
-		return response.json() as Promise<T>;
 	}
 }
 
 export function getAPIBaseURL(config?: Config | null): string {
-	if (process.env.AGENTUITY_API_URL) {
-		return process.env.AGENTUITY_API_URL;
-	}
-
 	const overrides = config?.overrides as { api_url?: string } | undefined;
-	if (overrides?.api_url) {
-		return overrides.api_url;
-	}
-
-	return 'https://api.agentuity.com';
+	return baseGetAPIBaseURL(overrides);
 }
 
 export function getAppBaseURL(config?: Config | null): string {
-	if (process.env.AGENTUITY_APP_URL) {
-		return process.env.AGENTUITY_APP_URL;
-	}
-
 	const overrides = config?.overrides as { app_url?: string } | undefined;
-	if (overrides?.app_url) {
-		return overrides.app_url;
-	}
-
-	return 'https://app.agentuity.com';
+	return baseGetAppBaseURL(overrides);
 }

package/src/auth.ts

@@ -1,9 +1,9 @@
 import { existsSync } from 'node:fs';
-import { getDefaultConfigDir, getAuth } from './config';
+import enquirer from 'enquirer';
+import { getDefaultConfigDir, getAuth, saveConfig, loadConfig } from './config';
 import { getCommand } from './command-prefix';
 import type { CommandContext, AuthData } from './types';
 import * as tui from './tui';
-import enquirer from 'enquirer';
 
 export function isTTY(): boolean {
 	return process.stdin.isTTY === true && process.stdout.isTTY === true;
@@ -91,76 +91,92 @@ export async function optionalAuth(
 		return auth;
 	}
 
-	if (!isTTY()) {
-		// In non-TTY mode, just return null
-		return null;
-	}
-
-	// Show signup benefits box
-	tui.showSignupBenefits();
-
-	// Show select menu with custom or default text
-	const defaultContinueText = 'Start without an account (run locally)';
-	const response = await enquirer.prompt<{ action: string }>({
-		type: 'select',
-		name: 'action',
-		message: 'How would you like to continue?',
-		choices: [
-			{
-				name: 'login',
-				message: 'Create an account or login',
-			},
-			{
-				name: 'local',
-				message: continueText || defaultContinueText,
-			},
-		],
-	});
-
-	if (response.action === 'local') {
-		return null;
-	}
-	tui.newline();
-
-	// Import and run login flow
-	const { loginCommand } = await import('./cmd/auth/login');
-	await loginCommand.handler(ctx);
+	// Show signup benefits but don't block - just return null
+	if (isTTY()) {
+		const config = await loadConfig();
+		// check to see if we've shown the banner or logged in before
+		const benefitsShown = config?.preferences?.signup_banner_shown === true;
+		const hasLoggedIn = hasLoggedInBefore();
+
+		// if we haven't shown it, show it once and then remember that we've shown it
+		if (!benefitsShown && hasLoggedIn) {
+			tui.showSignupBenefits();
+
+			if (!config) {
+				ctx.config = { name: 'production' };
+			} else {
+				ctx.config = config;
+			}
+
+			if (!ctx.config.preferences) {
+				ctx.config.preferences = {};
+			}
+			ctx.config.preferences.signup_banner_shown = true;
+			await saveConfig(ctx.config);
+
+			// Show select menu with custom or default text
+			const defaultContinueText = 'Start without an account (run locally)';
+			const response = await enquirer.prompt<{ action: string }>({
+				type: 'select',
+				name: 'action',
+				message: 'How would you like to continue?',
+				choices: [
+					{
+						name: 'login',
+						message: 'Create an account or login',
+					},
+					{
+						name: 'local',
+						message: continueText || defaultContinueText,
+					},
+				],
+			});
+
+			if (response.action === 'local') {
+				tui.showLoggedOutMessage();
+				return null;
+			}
+
+			tui.newline();
+
+			// Import and run login flow
+			const { loginCommand } = await import('./cmd/auth/login');
+			await loginCommand.handler(ctx);
+			return getAuth();
+		}
 
-	// After login completes, verify we have auth
-	const newAuth = await getAuth();
-	if (!newAuth || newAuth.expires <= new Date()) {
-		return null;
+		if (hasLoggedIn) {
+			tui.warning('You are not currently logged in');
+			tui.newline();
+			const response = await enquirer.prompt<{ action: string }>({
+				type: 'select',
+				name: 'action',
+				message: 'How would you like to continue?',
+				choices: [
+					{
+						name: 'local',
+						message: 'Continue without login',
+					},
+					{
+						name: 'login',
+						message: 'Login',
+					},
+				],
+			});
+
+			if (response.action === 'local') {
+				tui.showLoggedOutMessage();
+				return null;
+			}
+
+			tui.newline();
+
+			// Import and run login flow
+			const { loginCommand } = await import('./cmd/auth/login');
+			await loginCommand.handler(ctx);
+			return getAuth();
+		}
 	}
-	tui.newline();
-
-	return newAuth;
-}
 
-export function withAuth<TArgs extends unknown[]>(
-	ctx: CommandContext<false>,
-	handler: (ctx: CommandContext<true>, ...args: TArgs) => Promise<void> | void
-): (...args: TArgs) => Promise<void> {
-	return async (...args: TArgs) => {
-		const auth = await requireAuth(ctx);
-		const authenticatedCtx: CommandContext<true> = {
-			...ctx,
-			auth,
-		};
-		return handler(authenticatedCtx, ...args);
-	};
-}
-
-export function withOptionalAuth<TArgs extends unknown[]>(
-	ctx: CommandContext<false>,
-	handler: (
-		ctx: CommandContext<false>,
-		auth: AuthData | null,
-		...args: TArgs
-	) => Promise<void> | void,
-	continueText?: string
-): (...args: TArgs) => Promise<void> {
-	return async (...args: TArgs) => {
-		const auth = await optionalAuth(ctx, continueText);
-		return handler(ctx, auth, ...args);
-	};
+	return null;
 }

package/src/cli.ts

@@ -14,7 +14,7 @@ export async function createCLI(version: string): Promise<Command> {
 		.helpOption('-h, --help', 'Display help');
 
 	program
-		.option('--config <path>', 'Config file path', '~/.config/agentuity/config.yaml')
+		.option('--config <path>', 'Config file path', '~/.config/agentuity/production.yaml')
 		.option('--log-level <level>', 'Log level', 'info')
 		.option('--log-timestamp', 'Show timestamps in log output', false)
 		.option('--no-log-prefix', 'Hide log level prefixes', false)
@@ -131,7 +131,7 @@ async function registerSubcommand(
 					const input = buildValidationInput(subcommand.schema, args, options);
 					const ctx: Record<string, unknown> = {
 						...baseCtx,
-						...(auth ? { auth } : {}),
+						auth,
 					};
 					if (subcommand.schema.args) {
 						ctx.args = subcommand.schema.args.parse(input.args);
@@ -152,14 +152,9 @@ async function registerSubcommand(
 					}
 					throw error;
 				}
-			} else if (auth) {
-				const ctx: CommandContext<true> = {
-					...baseCtx,
-					auth,
-				};
-				await subcommand.handler(ctx);
 			} else {
-				await subcommand.handler(baseCtx as CommandContext<false>);
+				const ctx = { ...baseCtx, auth };
+				await subcommand.handler(ctx as CommandContext);
 			}
 		} else {
 			if (subcommand.schema) {
@@ -219,12 +214,8 @@ export async function registerCommands(
 						const continueText =
 							typeof cmdDef.optionalAuth === 'string' ? cmdDef.optionalAuth : undefined;
 						const auth = await optionalAuth(baseCtx as CommandContext<false>, continueText);
-						if (auth) {
-							const ctx: CommandContext<true> = { ...baseCtx, auth };
-							await cmdDef.handler!(ctx);
-						} else {
-							await cmdDef.handler!(baseCtx as CommandContext<false>);
-						}
+						const ctx = { ...baseCtx, auth };
+						await cmdDef.handler!(ctx as CommandContext);
 					} else {
 						await cmdDef.handler!(baseCtx as CommandContext<false>);
 					}

package/src/cmd/auth/api.ts

@@ -1,34 +1,36 @@
-import { APIClient, APIError } from '../../api';
+import { z } from 'zod';
+import { APIError, APIResponseSchema } from '@agentuity/server';
+import { APIClient } from '../../api';
 import type { Config } from '../../types';
 
-interface APIResponse<T> {
-	success: boolean;
-	message: string;
-	data?: T;
-}
+// Zod schemas for API validation
+const OTPStartDataSchema = z.object({
+	otp: z.string(),
+});
 
-interface OTPStartData {
-	otp: string;
-}
+const OTPCompleteDataSchema = z.object({
+	apiKey: z.string(),
+	userId: z.string(),
+	expires: z.number(),
+});
 
-interface OTPCompleteData {
-	apiKey: string;
-	userId: string;
-	expires: number;
-}
+const SignupCompleteDataSchema = z.object({
+	userId: z.string(),
+	apiKey: z.string(),
+	expiresAt: z.number(),
+});
 
+const OTPCheckRequestSchema = z.object({
+	otp: z.string(),
+});
+
+// Exported result types
 export interface LoginResult {
 	apiKey: string;
 	userId: string;
 	expires: Date;
 }
 
-interface SignupCompleteData {
-	userId: string;
-	apiKey: string;
-	expiresAt: number;
-}
-
 export interface SignupResult {
 	apiKey: string;
 	userId: string;
@@ -36,8 +38,12 @@ export interface SignupResult {
 }
 
 export async function generateLoginOTP(apiUrl: string, config?: Config | null): Promise<string> {
-	const client = new APIClient(apiUrl, undefined, config);
-	const resp = await client.request<APIResponse<OTPStartData>>('GET', '/cli/auth/start');
+	const client = new APIClient(apiUrl, config);
+	const resp = await client.request(
+		'GET',
+		'/cli/auth/start',
+		APIResponseSchema(OTPStartDataSchema)
+	);
 
 	if (!resp.success) {
 		throw new Error(resp.message);
@@ -56,13 +62,17 @@ export async function pollForLoginCompletion(
 	config?: Config | null,
 	timeoutMs = 60000
 ): Promise<LoginResult> {
-	const client = new APIClient(apiUrl, undefined, config);
+	const client = new APIClient(apiUrl, config);
 	const started = Date.now();
 
 	while (Date.now() - started < timeoutMs) {
-		const resp = await client.request<APIResponse<OTPCompleteData>>('POST', '/cli/auth/check', {
-			otp,
-		});
+		const resp = await client.request(
+			'POST',
+			'/cli/auth/check',
+			APIResponseSchema(OTPCompleteDataSchema),
+			{ otp },
+			OTPCheckRequestSchema
+		);
 
 		if (!resp.success) {
 			throw new Error(resp.message);
@@ -99,14 +109,15 @@ export async function pollForSignupCompletion(
 	config?: Config | null,
 	timeoutMs = 300000
 ): Promise<SignupResult> {
-	const client = new APIClient(apiUrl, undefined, config);
+	const client = new APIClient(apiUrl, config);
 	const started = Date.now();
 
 	while (Date.now() - started < timeoutMs) {
 		try {
-			const resp = await client.request<APIResponse<SignupCompleteData>>(
+			const resp = await client.request(
 				'GET',
-				`/cli/auth/signup/${otp}`
+				`/cli/auth/signup/${otp}`,
+				APIResponseSchema(SignupCompleteDataSchema)
 			);
 
 			if (!resp.success) {

package/src/cmd/auth/login.ts

@@ -1,10 +1,11 @@
-import type { SubcommandDefinition } from '../../types';
-import { getAPIBaseURL, getAppBaseURL, UpgradeRequiredError } from '../../api';
+import { createSubcommand } from '../../types';
+import { UpgradeRequiredError } from '@agentuity/server';
+import { getAPIBaseURL, getAppBaseURL } from '../../api';
 import { saveAuth } from '../../config';
 import { generateLoginOTP, pollForLoginCompletion } from './api';
 import * as tui from '../../tui';
 
-export const loginCommand: SubcommandDefinition = {
+export const loginCommand = createSubcommand({
 	name: 'login',
 	description: 'Login to the Agentuity Platform using a browser-based authentication flow',
 	toplevel: true,
@@ -45,18 +46,6 @@ export const loginCommand: SubcommandDefinition = {
 			console.log(tui.muted('This code will expire in 60 seconds'));
 			tui.newline();
 
-			if (process.platform === 'darwin') {
-				await tui.waitForAnyKey('Press any key to open the URL in your browser...');
-				tui.newline();
-				try {
-					Bun.spawn(['open', authURL], {
-						stdio: ['ignore', 'ignore', 'ignore'],
-					});
-				} catch {
-					// Ignore browser open errors
-				}
-			}
-
 			console.log('Waiting for login to complete...');
 
 			const result = await pollForLoginCompletion(apiUrl, otp, config);
@@ -81,4 +70,4 @@ export const loginCommand: SubcommandDefinition = {
 			}
 		}
 	},
-};
+});

package/src/cmd/auth/logout.ts

@@ -1,8 +1,8 @@
-import type { SubcommandDefinition } from '../../types';
+import { createSubcommand } from '../../types';
 import { clearAuth } from '../../config';
 import * as tui from '../../tui';
 
-export const logoutCommand: SubcommandDefinition = {
+export const logoutCommand = createSubcommand({
 	name: 'logout',
 	description: 'Logout of the Agentuity Cloud Platform',
 	toplevel: true,
@@ -11,4 +11,4 @@ export const logoutCommand: SubcommandDefinition = {
 		await clearAuth();
 		tui.success('You have been logged out');
 	},
-};
+});

package/src/cmd/auth/signup.ts

@@ -1,18 +1,18 @@
-import type { SubcommandDefinition } from '../../types';
-import { getAPIBaseURL, getAppBaseURL, UpgradeRequiredError } from '../../api';
+import { createSubcommand } from '../../types';
+import { getAPIBaseURL, getAppBaseURL, UpgradeRequiredError } from '@agentuity/server';
 import { saveAuth } from '../../config';
 import { generateSignupOTP, pollForSignupCompletion } from './api';
 import * as tui from '../../tui';
 
-export const signupCommand: SubcommandDefinition = {
+export const signupCommand = createSubcommand({
 	name: 'signup',
 	description: 'Create a new Agentuity Cloud Platform account',
 	toplevel: true,
 
 	async handler(ctx) {
 		const { logger, config } = ctx;
-		const apiUrl = getAPIBaseURL(config);
-		const appUrl = getAppBaseURL(config);
+		const apiUrl = getAPIBaseURL(config?.overrides);
+		const appUrl = getAppBaseURL(config?.overrides);
 
 		try {
 			const otp = generateSignupOTP();
@@ -48,4 +48,4 @@ export const signupCommand: SubcommandDefinition = {
 			}
 		}
 	},
-};
+});

package/src/cmd/bundle/bundler.ts

@@ -7,6 +7,7 @@ import { getVersion } from '../../version';
 export interface BundleOptions {
 	rootDir: string;
 	dev?: boolean;
+	env?: Map<string, string>;
 }
 
 export async function bundle({ dev = false, rootDir }: BundleOptions) {

package/src/cmd/bundle/patch/index.ts

@@ -1,4 +1,5 @@
 import { generatePatches as aisdkGeneratePatches } from './aisdk';
+import { generatePatches as llmGeneratePatches } from './llm';
 import { type PatchModule, searchBackwards } from './_util';
 
 export function generatePatches(): Map<string, PatchModule> {
@@ -6,6 +7,9 @@ export function generatePatches(): Map<string, PatchModule> {
 	for (const [name, patch] of aisdkGeneratePatches()) {
 		patches.set(name, patch);
 	}
+	for (const [name, patch] of llmGeneratePatches()) {
+		patches.set(name, patch);
+	}
 	return patches;
 }
 

package/src/cmd/bundle/patch/llm.ts

@@ -0,0 +1,36 @@
+import { type PatchModule, generateEnvGuard, generateGatewayEnvGuard } from './_util';
+
+function registerLLMPatch(
+	patches: Map<string, PatchModule>,
+	module: string,
+	filename: string,
+	key: string,
+	baseurl: string,
+	name: string
+) {
+	patches.set(module, {
+		module,
+		filename,
+		body: {
+			before: generateEnvGuard(
+				key,
+				generateGatewayEnvGuard(key, 'process.env.AGENTUITY_SDK_KEY', baseurl, name)
+			),
+		},
+	});
+}
+
+export function generatePatches(): Map<string, PatchModule> {
+	const patches = new Map<string, PatchModule>();
+	registerLLMPatch(
+		patches,
+		'@anthropic-ai',
+		'index',
+		'ANTHROPIC_API_KEY',
+		'ANTHROPIC_BASE_URL',
+		'anthropic'
+	);
+	registerLLMPatch(patches, 'groq-sdk', 'index', 'GROQ_API_KEY', 'GROQ_BASE_URL', 'groq');
+	registerLLMPatch(patches, 'openai', 'index', 'OPENAI_API_KEY', 'OPENAI_BASE_URL', 'openai');
+	return patches;
+}