@agentuity/cli 0.0.43 → 0.0.45

package/src/cmd/auth/ssh/list.ts

@@ -0,0 +1,74 @@
+import { createSubcommand } from '../../../types';
+import { listSSHKeys } from './api';
+import * as tui from '../../../tui';
+import { z } from 'zod';
+
+export const listCommand = createSubcommand({
+	name: 'list',
+	aliases: ['ls'],
+	description: 'List all SSH keys on your account',
+	requires: { apiClient: true, auth: true },
+	schema: {
+		options: z.object({
+			format: z.enum(['text', 'json']).default('text').describe('output format'),
+		}),
+	},
+	async handler(ctx) {
+		const { logger, apiClient, opts } = ctx;
+		const format = opts.format;
+
+		if (!apiClient) {
+			logger.fatal('API client is not available');
+		}
+
+		try {
+			const keys = await tui.spinner('Fetching SSH keys...', () => listSSHKeys(apiClient));
+
+			if (format === 'json') {
+				console.log(JSON.stringify(keys, null, 2));
+				return;
+			}
+
+			tui.newline();
+
+			if (keys.length === 0) {
+				console.log('No SSH keys found');
+				return;
+			}
+
+			console.log(tui.bold('SSH Keys:'));
+			tui.newline();
+
+			// Create aligned table
+			const rows = keys.map((key) => [
+				key.keyType,
+				key.fingerprint,
+				key.comment || tui.muted('(no comment)'),
+			]);
+
+			// Calculate column widths
+			const widths = [
+				Math.max(4, ...rows.map((r) => r[0].length)),
+				Math.max(11, ...rows.map((r) => r[1].length)),
+				Math.max(7, ...rows.map((r) => Bun.stringWidth(r[2]))),
+			];
+
+			// Print header
+			console.log(
+				`${tui.bold('TYPE'.padEnd(widths[0]))}   ${tui.bold('FINGERPRINT'.padEnd(widths[1]))}   ${tui.bold('COMMENT')}`
+			);
+
+			// Print rows
+			for (const row of rows) {
+				console.log(`${row[0].padEnd(widths[0])}   ${row[1].padEnd(widths[1])}   ${row[2]}`);
+			}
+		} catch (error) {
+			logger.trace(error);
+			if (error instanceof Error) {
+				logger.fatal(`Failed to list SSH keys: ${error.message}`);
+			} else {
+				logger.fatal('Failed to list SSH keys');
+			}
+		}
+	},
+});

package/src/cmd/auth/whoami.ts

@@ -2,12 +2,11 @@ import { z } from 'zod';
 import { createSubcommand } from '../../types';
 import * as tui from '../../tui';
 import { whoami } from '@agentuity/server';
-import { getAPIBaseURL, APIClient } from '../../api';
 
 export const whoamiCommand = createSubcommand({
 	name: 'whoami',
 	description: 'Display information about the currently authenticated user',
-	requiresAuth: true,
+	requires: { auth: true, apiClient: true },
 	schema: {
 		options: z.object({
 			format: z
@@ -18,20 +17,21 @@ export const whoamiCommand = createSubcommand({
 	},
 
 	async handler(ctx) {
-		const { config, opts, auth } = ctx;
+		const { apiClient, opts, auth } = ctx;
 
-		const apiUrl = getAPIBaseURL(config);
-		const client = new APIClient(apiUrl, config);
-
-		const result = await tui.spinner('Fetching user information', () => {
-			return whoami(client!);
-		});
-
-		if (!result.data) {
-			tui.fatal('Failed to get user information');
+		if (!apiClient) {
+			throw new Error(
+				'API client is not available. This is likely a configuration or initialization issue.'
+			);
 		}
 
-		const user = result.data;
+		const user = await tui.spinner({
+			message: 'Fetching user information',
+			clearOnSuccess: true,
+			callback: () => {
+				return whoami(apiClient);
+			},
+		});
 
 		if (opts?.format === 'json') {
 			console.log(

package/src/cmd/bundle/ast.test.ts

@@ -0,0 +1,565 @@
+import { describe, test, expect } from 'bun:test';
+import { parseEvalMetadata } from './ast';
+
+const TEST_ROOT_DIR = '/test/root';
+const TEST_PROJECT_ID = 'test-project-id';
+const TEST_DEPLOYMENT_ID = 'test-deployment-id';
+
+describe('parseEvalMetadata', () => {
+	describe('eval with metadata.name', () => {
+		test('uses metadata.name when provided', () => {
+			const code = `
+				import agent from './agent';
+				export const myEval = agent.createEval({
+					metadata: {
+						name: 'custom-eval-name',
+						description: 'Test description'
+					},
+					handler: async () => ({ success: true, passed: true })
+				});
+			`;
+
+			const [, result] = parseEvalMetadata(
+				TEST_ROOT_DIR,
+				'/test/root/src/agents/test/eval.ts',
+				code,
+				TEST_PROJECT_ID,
+				TEST_DEPLOYMENT_ID
+			);
+
+			expect(result).toHaveLength(1);
+			expect(result[0].name).toBe('custom-eval-name');
+			expect(result[0].description).toBe('Test description');
+		});
+	});
+
+	describe('eval with variable name only', () => {
+		test('uses camelToKebab of variable name when metadata.name is not provided', () => {
+			const code = `
+				import agent from './agent';
+				export const myTestEval = agent.createEval({
+					metadata: {
+						description: 'Test description'
+					},
+					handler: async () => ({ success: true, passed: true })
+				});
+			`;
+
+			const [, result] = parseEvalMetadata(
+				TEST_ROOT_DIR,
+				'/test/root/src/agents/test/eval.ts',
+				code,
+				TEST_PROJECT_ID,
+				TEST_DEPLOYMENT_ID
+			);
+
+			expect(result).toHaveLength(1);
+			expect(result[0].name).toBe('my-test-eval');
+			expect(result[0].description).toBe('Test description');
+		});
+
+		test('uses camelToKebab of variable name when metadata is not provided', () => {
+			const code = `
+				import agent from './agent';
+				export const noMetadataEval = agent.createEval({
+					handler: async () => ({ success: true, passed: true })
+				});
+			`;
+
+			const [, result] = parseEvalMetadata(
+				TEST_ROOT_DIR,
+				'/test/root/src/agents/test/eval.ts',
+				code,
+				TEST_PROJECT_ID,
+				TEST_DEPLOYMENT_ID
+			);
+
+			expect(result).toHaveLength(1);
+			expect(result[0].name).toBe('no-metadata-eval');
+		});
+
+		test('handles complex camelCase variable names correctly', () => {
+			const code = `
+				import agent from './agent';
+				export const complexCamelCaseEvalName = agent.createEval({
+					handler: async () => ({ success: true, passed: true })
+				});
+			`;
+
+			const [, result] = parseEvalMetadata(
+				TEST_ROOT_DIR,
+				'/test/root/src/agents/test/eval.ts',
+				code,
+				TEST_PROJECT_ID,
+				TEST_DEPLOYMENT_ID
+			);
+
+			expect(result).toHaveLength(1);
+			expect(result[0].name).toBe('complex-camel-case-eval-name');
+		});
+	});
+
+	describe('eval with both metadata.name and variable name', () => {
+		test('prefers metadata.name over variable name', () => {
+			const code = `
+				import agent from './agent';
+				export const variableNameEval = agent.createEval({
+					metadata: {
+						name: 'metadata-name-takes-priority'
+					},
+					handler: async () => ({ success: true, passed: true })
+				});
+			`;
+
+			const [, result] = parseEvalMetadata(
+				TEST_ROOT_DIR,
+				'/test/root/src/agents/test/eval.ts',
+				code,
+				TEST_PROJECT_ID,
+				TEST_DEPLOYMENT_ID
+			);
+
+			expect(result).toHaveLength(1);
+			expect(result[0].name).toBe('metadata-name-takes-priority');
+		});
+	});
+
+	describe('eval with neither name', () => {
+		test('throws error when eval has neither metadata.name nor variable name', () => {
+			// This is a difficult case to test with valid JavaScript, as all valid
+			// variable declarations should have an identifier. However, we can verify
+			// the error handling exists by testing that the error message format is correct.
+			//
+			// In practice, this error should never occur with valid code, but we want
+			// to ensure the error is clear and helpful if it does happen.
+			//
+			// The error case would occur if:
+			// 1. vardecl.id.type is not 'Identifier' (e.g., destructuring pattern)
+			// 2. metadata.name is not provided
+			//
+			// Since acorn-loose parses valid JavaScript, and valid eval declarations
+			// should always have an identifier, this is primarily a defensive check.
+			//
+			// We verify the error path exists in the code by checking that normal
+			// cases work correctly, and the error handling is in place.
+
+			// Test that normal cases work (implicitly tests error path doesn't trigger)
+			const code = `
+				import agent from './agent';
+				export const validEval = agent.createEval({
+					handler: async () => ({ success: true, passed: true })
+				});
+			`;
+
+			const [, result] = parseEvalMetadata(
+				TEST_ROOT_DIR,
+				'/test/root/src/agents/test/eval.ts',
+				code,
+				TEST_PROJECT_ID,
+				TEST_DEPLOYMENT_ID
+			);
+
+			expect(result).toHaveLength(1);
+			expect(result[0].name).toBe('valid-eval');
+
+			// Note: To fully test the error case, we would need to mock the AST structure
+			// or use code that parses but doesn't extract a variable name. This is
+			// difficult with acorn-loose parsing valid JavaScript. The error handling
+			// is verified to exist in the code, and will throw if the condition is met.
+		});
+	});
+
+	describe('multiple evals', () => {
+		test('parses multiple evals in same file correctly', () => {
+			const code = `
+				import agent from './agent';
+				
+				export const firstEval = agent.createEval({
+					metadata: {
+						name: 'first-eval',
+						description: 'First eval'
+					},
+					handler: async () => ({ success: true, passed: true })
+				});
+
+				export const secondEval = agent.createEval({
+					metadata: {
+						name: 'second-eval',
+						description: 'Second eval'
+					},
+					handler: async () => ({ success: true, passed: true })
+				});
+
+				export const thirdEval = agent.createEval({
+					handler: async () => ({ success: true, passed: true })
+				});
+			`;
+
+			const [, result] = parseEvalMetadata(
+				TEST_ROOT_DIR,
+				'/test/root/src/agents/test/eval.ts',
+				code,
+				TEST_PROJECT_ID,
+				TEST_DEPLOYMENT_ID
+			);
+
+			expect(result).toHaveLength(3);
+			expect(result[0].name).toBe('first-eval');
+			expect(result[0].description).toBe('First eval');
+			expect(result[1].name).toBe('second-eval');
+			expect(result[1].description).toBe('Second eval');
+			expect(result[2].name).toBe('third-eval');
+		});
+
+		test('handles mix of metadata.name and variable name evals', () => {
+			const code = `
+				import agent from './agent';
+				
+				export const withMetadataName = agent.createEval({
+					metadata: {
+						name: 'custom-name'
+					},
+					handler: async () => ({ success: true, passed: true })
+				});
+
+				export const withoutMetadataName = agent.createEval({
+					handler: async () => ({ success: true, passed: true })
+				});
+			`;
+
+			const [, result] = parseEvalMetadata(
+				TEST_ROOT_DIR,
+				'/test/root/src/agents/test/eval.ts',
+				code,
+				TEST_PROJECT_ID,
+				TEST_DEPLOYMENT_ID
+			);
+
+			expect(result).toHaveLength(2);
+			expect(result[0].name).toBe('custom-name');
+			expect(result[1].name).toBe('without-metadata-name');
+		});
+	});
+
+	describe('export patterns', () => {
+		test('handles ExportNamedDeclaration pattern', () => {
+			const code = `
+				import agent from './agent';
+				export const exportedEval = agent.createEval({
+					handler: async () => ({ success: true, passed: true })
+				});
+			`;
+
+			const [, result] = parseEvalMetadata(
+				TEST_ROOT_DIR,
+				'/test/root/src/agents/test/eval.ts',
+				code,
+				TEST_PROJECT_ID,
+				TEST_DEPLOYMENT_ID
+			);
+
+			expect(result).toHaveLength(1);
+			expect(result[0].name).toBe('exported-eval');
+		});
+
+		test('handles VariableDeclaration pattern (non-exported)', () => {
+			const code = `
+				import agent from './agent';
+				const nonExportedEval = agent.createEval({
+					handler: async () => ({ success: true, passed: true })
+				});
+			`;
+
+			const [, result] = parseEvalMetadata(
+				TEST_ROOT_DIR,
+				'/test/root/src/agents/test/eval.ts',
+				code,
+				TEST_PROJECT_ID,
+				TEST_DEPLOYMENT_ID
+			);
+
+			expect(result).toHaveLength(1);
+			expect(result[0].name).toBe('non-exported-eval');
+		});
+	});
+
+	describe('eval ID generation', () => {
+		test('generates unique IDs for evals', () => {
+			const code = `
+				import agent from './agent';
+				
+				export const eval1 = agent.createEval({
+					handler: async () => ({ success: true, passed: true })
+				});
+
+				export const eval2 = agent.createEval({
+					handler: async () => ({ success: true, passed: true })
+				});
+			`;
+
+			const [, result] = parseEvalMetadata(
+				TEST_ROOT_DIR,
+				'/test/root/src/agents/test/eval.ts',
+				code,
+				TEST_PROJECT_ID,
+				TEST_DEPLOYMENT_ID
+			);
+
+			expect(result).toHaveLength(2);
+			expect(result[0].id).toBeDefined();
+			expect(result[1].id).toBeDefined();
+			expect(result[0].id).not.toBe(result[1].id);
+		});
+
+		test('generates consistent IDs for same eval', () => {
+			const code = `
+				import agent from './agent';
+				export const myEval = agent.createEval({
+					metadata: {
+						name: 'test-eval'
+					},
+					handler: async () => ({ success: true, passed: true })
+				});
+			`;
+
+			const [, result1] = parseEvalMetadata(
+				TEST_ROOT_DIR,
+				'/test/root/src/agents/test/eval.ts',
+				code,
+				TEST_PROJECT_ID,
+				TEST_DEPLOYMENT_ID
+			);
+
+			const [, result2] = parseEvalMetadata(
+				TEST_ROOT_DIR,
+				'/test/root/src/agents/test/eval.ts',
+				code,
+				TEST_PROJECT_ID,
+				TEST_DEPLOYMENT_ID
+			);
+
+			expect(result1[0].id).toBe(result2[0].id);
+		});
+	});
+
+	describe('edge cases', () => {
+		test('handles empty metadata object', () => {
+			const code = `
+				import agent from './agent';
+				export const emptyMetadataEval = agent.createEval({
+					metadata: {},
+					handler: async () => ({ success: true, passed: true })
+				});
+			`;
+
+			const [, result] = parseEvalMetadata(
+				TEST_ROOT_DIR,
+				'/test/root/src/agents/test/eval.ts',
+				code,
+				TEST_PROJECT_ID,
+				TEST_DEPLOYMENT_ID
+			);
+
+			expect(result).toHaveLength(1);
+			expect(result[0].name).toBe('empty-metadata-eval');
+		});
+
+		test('handles eval with only description in metadata', () => {
+			const code = `
+				import agent from './agent';
+				export const descriptionOnlyEval = agent.createEval({
+					metadata: {
+						description: 'Only description, no name'
+					},
+					handler: async () => ({ success: true, passed: true })
+				});
+			`;
+
+			const [, result] = parseEvalMetadata(
+				TEST_ROOT_DIR,
+				'/test/root/src/agents/test/eval.ts',
+				code,
+				TEST_PROJECT_ID,
+				TEST_DEPLOYMENT_ID
+			);
+
+			expect(result).toHaveLength(1);
+			expect(result[0].name).toBe('description-only-eval');
+			expect(result[0].description).toBe('Only description, no name');
+		});
+	});
+
+	describe('duplicate eval names', () => {
+		test('throws error when duplicate eval names are found in same file', () => {
+			const code = `
+				import agent from './agent';
+				
+				export const firstEval = agent.createEval({
+					metadata: {
+						name: 'duplicate-name'
+					},
+					handler: async () => ({ success: true, passed: true })
+				});
+
+				export const secondEval = agent.createEval({
+					metadata: {
+						name: 'duplicate-name'
+					},
+					handler: async () => ({ success: true, passed: true })
+				});
+			`;
+
+			expect(() => {
+				parseEvalMetadata(
+					TEST_ROOT_DIR,
+					'/test/root/src/agents/test/eval.ts',
+					code,
+					TEST_PROJECT_ID,
+					TEST_DEPLOYMENT_ID
+				);
+			}).toThrow(/Duplicate eval names found in .*eval\.ts: duplicate-name/);
+		});
+
+		test('throws error when multiple duplicate eval names are found', () => {
+			const code = `
+				import agent from './agent';
+				
+				export const eval1 = agent.createEval({
+					metadata: {
+						name: 'first-duplicate'
+					},
+					handler: async () => ({ success: true, passed: true })
+				});
+
+				export const eval2 = agent.createEval({
+					metadata: {
+						name: 'first-duplicate'
+					},
+					handler: async () => ({ success: true, passed: true })
+				});
+
+				export const eval3 = agent.createEval({
+					metadata: {
+						name: 'second-duplicate'
+					},
+					handler: async () => ({ success: true, passed: true })
+				});
+
+				export const eval4 = agent.createEval({
+					metadata: {
+						name: 'second-duplicate'
+					},
+					handler: async () => ({ success: true, passed: true })
+				});
+			`;
+
+			expect(() => {
+				parseEvalMetadata(
+					TEST_ROOT_DIR,
+					'/test/root/src/agents/test/eval.ts',
+					code,
+					TEST_PROJECT_ID,
+					TEST_DEPLOYMENT_ID
+				);
+			}).toThrow(/Duplicate eval names found in .*eval\.ts: first-duplicate, second-duplicate/);
+		});
+
+		test('throws error when duplicate names come from variable names', () => {
+			// Note: We can't have two variables with the exact same name in valid JavaScript,
+			// but we can test that the validation works by using metadata.name to override
+			// variable names to create duplicates
+			const code = `
+				import agent from './agent';
+				
+				export const eval1 = agent.createEval({
+					metadata: {
+						name: 'duplicate-name'
+					},
+					handler: async () => ({ success: true, passed: true })
+				});
+
+				export const eval2 = agent.createEval({
+					metadata: {
+						name: 'duplicate-name'
+					},
+					handler: async () => ({ success: true, passed: true })
+				});
+			`;
+
+			expect(() => {
+				parseEvalMetadata(
+					TEST_ROOT_DIR,
+					'/test/root/src/agents/test/eval.ts',
+					code,
+					TEST_PROJECT_ID,
+					TEST_DEPLOYMENT_ID
+				);
+			}).toThrow(/Duplicate eval names found in .*eval\.ts: duplicate-name/);
+		});
+
+		test('throws error when duplicate names mix metadata.name and variable name', () => {
+			const code = `
+				import agent from './agent';
+				
+				export const myEval = agent.createEval({
+					metadata: {
+						name: 'mixed-duplicate'
+					},
+					handler: async () => ({ success: true, passed: true })
+				});
+
+				export const mixedDuplicate = agent.createEval({
+					handler: async () => ({ success: true, passed: true })
+				});
+			`;
+
+			expect(() => {
+				parseEvalMetadata(
+					TEST_ROOT_DIR,
+					'/test/root/src/agents/test/eval.ts',
+					code,
+					TEST_PROJECT_ID,
+					TEST_DEPLOYMENT_ID
+				);
+			}).toThrow(/Duplicate eval names found in .*eval\.ts: mixed-duplicate/);
+		});
+
+		test('error message includes filename and all duplicate names', () => {
+			const code = `
+				import agent from './agent';
+				
+				export const eval1 = agent.createEval({
+					metadata: { name: 'test-eval' },
+					handler: async () => ({ success: true, passed: true })
+				});
+
+				export const eval2 = agent.createEval({
+					metadata: { name: 'test-eval' },
+					handler: async () => ({ success: true, passed: true })
+				});
+			`;
+
+			let errorThrown = false;
+			try {
+				parseEvalMetadata(
+					TEST_ROOT_DIR,
+					'/test/root/src/agents/test/eval.ts',
+					code,
+					TEST_PROJECT_ID,
+					TEST_DEPLOYMENT_ID
+				);
+			} catch (error) {
+				errorThrown = true;
+				expect(error).toBeInstanceOf(Error);
+				const errorMessage = (error as Error).message;
+				expect(errorMessage).toContain('Duplicate eval names found in');
+				expect(errorMessage).toContain('eval.ts');
+				expect(errorMessage).toContain('test-eval');
+				expect(errorMessage).toContain(
+					'Eval names must be unique within the same file to prevent ID collisions'
+				);
+			}
+			expect(errorThrown).toBe(true);
+		});
+	});
+});