@agentuity/cli 0.0.53 → 0.0.54

package/src/cli.ts

@@ -51,7 +51,8 @@ function createAPIClient(baseCtx: CommandContext, config: Config | null): APICli
 async function executeOrValidate(
 	ctx: CommandContext,
 	commandName: string,
-	handler?: (ctx: CommandContext) => unknown | Promise<unknown>
+	handler?: (ctx: CommandContext) => unknown | Promise<unknown>,
+	hasResponseSchema?: boolean
 ): Promise<void> {
 	if (isValidateMode(ctx.options)) {
 		// In validate mode, just output success (validation already passed via Zod)
@@ -62,7 +63,29 @@ async function executeOrValidate(
 		outputValidation(result, ctx.options);
 	} else if (handler) {
 		// Normal execution
-		await handler(ctx);
+		const result = await handler(ctx);
+
+		// If --json flag is set
+		if (ctx.options.json) {
+			// If command has a response schema but returned nothing, that's an error
+			if (hasResponseSchema && result === undefined) {
+				const { createError, exitWithError, ErrorCode } = await import('./errors');
+				exitWithError(
+					createError(
+						ErrorCode.INTERNAL_ERROR,
+						`Command '${commandName}' declares a response schema but returned no data. This is a bug in the command implementation.`
+					),
+					ctx.logger,
+					ctx.options.errorFormat
+				);
+			}
+
+			// Output the result as JSON if we have data
+			if (result !== undefined) {
+				const { outputJSON } = await import('./output');
+				outputJSON(result);
+			}
+		}
 	}
 }
 
@@ -593,7 +616,8 @@ async function registerSubcommand(
 					await executeOrValidate(
 						ctx as CommandContext,
 						`${parent.name()} ${subcommand.name}`,
-						subcommand.handler
+						subcommand.handler,
+						!!subcommand.schema?.response
 					);
 				} catch (error) {
 					if (error && typeof error === 'object' && 'issues' in error) {
@@ -653,7 +677,32 @@ async function registerSubcommand(
 					}
 				}
 				if (subcommand.handler) {
-					await subcommand.handler(ctx as CommandContext);
+					const result = await subcommand.handler(ctx as CommandContext);
+
+					// If --json flag is set
+					if (baseCtx.options.json) {
+						// eslint-disable-next-line @typescript-eslint/no-explicit-any
+						const hasResponseSchema = !!(subcommand as any).schema?.response;
+
+						// If command has a response schema but returned nothing, that's an error
+						if (hasResponseSchema && result === undefined) {
+							const { createError, exitWithError, ErrorCode } = await import('./errors');
+							exitWithError(
+								createError(
+									ErrorCode.INTERNAL_ERROR,
+									`Command '${parent.name()} ${subcommand.name}' declares a response schema but returned no data. This is a bug in the command implementation.`
+								),
+								baseCtx.logger,
+								baseCtx.options.errorFormat
+							);
+						}
+
+						// Output the result as JSON if we have data
+						if (result !== undefined) {
+							const { outputJSON } = await import('./output');
+							outputJSON(result);
+						}
+					}
 				}
 			}
 		} else if (normalized.optionalAuth) {
@@ -740,7 +789,8 @@ async function registerSubcommand(
 					await executeOrValidate(
 						ctx as CommandContext,
 						`${parent.name()} ${subcommand.name}`,
-						subcommand.handler
+						subcommand.handler,
+						!!subcommand.schema?.response
 					);
 				} catch (error) {
 					if (error && typeof error === 'object' && 'issues' in error) {
@@ -799,7 +849,32 @@ async function registerSubcommand(
 					}
 				}
 				if (subcommand.handler) {
-					await subcommand.handler(ctx as CommandContext);
+					const result = await subcommand.handler(ctx as CommandContext);
+
+					// If --json flag is set
+					if (baseCtx.options.json) {
+						// eslint-disable-next-line @typescript-eslint/no-explicit-any
+						const hasResponseSchema = !!(subcommand as any).schema?.response;
+
+						// If command has a response schema but returned nothing, that's an error
+						if (hasResponseSchema && result === undefined) {
+							const { createError, exitWithError, ErrorCode } = await import('./errors');
+							exitWithError(
+								createError(
+									ErrorCode.INTERNAL_ERROR,
+									`Command '${parent.name()} ${subcommand.name}' declares a response schema but returned no data. This is a bug in the command implementation.`
+								),
+								baseCtx.logger,
+								baseCtx.options.errorFormat
+							);
+						}
+
+						// Output the result as JSON if we have data
+						if (result !== undefined) {
+							const { outputJSON } = await import('./output');
+							outputJSON(result);
+						}
+					}
 				}
 			}
 		} else {
@@ -837,7 +912,8 @@ async function registerSubcommand(
 					await executeOrValidate(
 						ctx as CommandContext,
 						`${parent.name()} ${subcommand.name}`,
-						subcommand.handler
+						subcommand.handler,
+						!!subcommand.schema?.response
 					);
 				} catch (error) {
 					if (error && typeof error === 'object' && 'issues' in error) {
@@ -882,7 +958,32 @@ async function registerSubcommand(
 					}
 				}
 				if (subcommand.handler) {
-					await subcommand.handler(ctx as CommandContext);
+					const result = await subcommand.handler(ctx as CommandContext);
+
+					// If --json flag is set
+					if (baseCtx.options.json) {
+						// eslint-disable-next-line @typescript-eslint/no-explicit-any
+						const hasResponseSchema = !!(subcommand as any).schema?.response;
+
+						// If command has a response schema but returned nothing, that's an error
+						if (hasResponseSchema && result === undefined) {
+							const { createError, exitWithError, ErrorCode } = await import('./errors');
+							exitWithError(
+								createError(
+									ErrorCode.INTERNAL_ERROR,
+									`Command '${parent.name()} ${subcommand.name}' declares a response schema but returned no data. This is a bug in the command implementation.`
+								),
+								baseCtx.logger,
+								baseCtx.options.errorFormat
+							);
+						}
+
+						// Output the result as JSON if we have data
+						if (result !== undefined) {
+							const { outputJSON } = await import('./output');
+							outputJSON(result);
+						}
+					}
 				}
 			}
 		}

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

@@ -132,7 +132,7 @@ export const addCommand = createSubcommand({
 		const { logger, apiClient, opts } = ctx;
 
 		if (!apiClient) {
-			logger.fatal('API client is not available', ErrorCode.INTERNAL_ERROR);
+			return logger.fatal('API client is not available', ErrorCode.INTERNAL_ERROR) as never;
 		}
 
 		try {
@@ -143,9 +143,9 @@ export const addCommand = createSubcommand({
 				try {
 					publicKey = readFileSync(opts.file, 'utf-8').trim();
 				} catch (error) {
-					logger.fatal(
+					return logger.fatal(
 						`Error reading file: ${error instanceof Error ? error.message : 'Unknown error'}`
-					);
+					) as never;
 				}
 			} else {
 				const stdin = await readStdinIfPiped();
@@ -157,11 +157,10 @@ export const addCommand = createSubcommand({
 					const discoveredKeys = discoverSSHKeys();
 
 					if (discoveredKeys.length === 0) {
-						logger.fatal(
+						return logger.fatal(
 							'No SSH public keys found in ~/.ssh/\n' +
 								'Please specify a file with --file or pipe the key via stdin'
-						);
-						return;
+						) as never;
 					}
 
 					// Fetch existing keys from server to filter out already-added ones
@@ -185,14 +184,13 @@ export const addCommand = createSubcommand({
 						console.log('To add a different key:');
 						tui.bullet(`Use ${tui.bold('--file <path>')} to specify a key file`);
 						tui.bullet(`Pipe the key via stdin: ${boldcmd}`);
-						return;
+						return { success: false, fingerprint: '', keyType: '', added: 0 };
 					}
 
 					if (!process.stdin.isTTY) {
-						logger.fatal(
+						return logger.fatal(
 							'Interactive selection required but cannot prompt in non-TTY environment. Use --file or pipe the key via stdin.'
-						);
-						return;
+						) as never;
 					}
 
 					const response = await enquirer.prompt<{ keys: string[] }>({
@@ -213,13 +211,17 @@ export const addCommand = createSubcommand({
 					if (selectedFingerprints.length === 0) {
 						tui.newline();
 						tui.info('No keys selected');
-						return;
+						return { success: false, fingerprint: '', keyType: '', added: 0 };
 					}
 
 					// Build Map for O(1) lookups
 					const keyMap = new Map(newKeys.map((k) => [k.fingerprint, k]));
 
 					// Add all selected keys
+					let addedCount = 0;
+					let lastFingerprint = '';
+					let lastKeyType = '';
+
 					for (const fingerprint of selectedFingerprints) {
 						const key = keyMap.get(fingerprint);
 						if (!key) continue;
@@ -232,6 +234,9 @@ export const addCommand = createSubcommand({
 								clearOnSuccess: true,
 							});
 							tui.success(`SSH key added: ${tui.muted(result.fingerprint)}`);
+							addedCount++;
+							lastFingerprint = result.fingerprint;
+							lastKeyType = key.publicKey.split(/\s+/)[0] || 'unknown';
 						} catch (error) {
 							tui.newline();
 							if (error instanceof Error) {
@@ -242,22 +247,27 @@ export const addCommand = createSubcommand({
 						}
 					}
 
-					return;
+					return {
+						success: addedCount > 0,
+						fingerprint: lastFingerprint,
+						keyType: lastKeyType,
+						added: addedCount,
+					};
 				}
 			}
 
 			// Only process single key if we got here (from --file or stdin)
 			if (!publicKey) {
-				logger.fatal('No public key provided');
+				return logger.fatal('No public key provided') as never;
 			}
 
 			// Validate key format
 			try {
 				computeSSHKeyFingerprint(publicKey);
 			} catch (error) {
-				logger.fatal(
+				return logger.fatal(
 					`Invalid SSH key format: ${error instanceof Error ? error.message : 'Unknown error'}`
-				);
+				) as never;
 			}
 
 			const result = await tui.spinner({
@@ -268,12 +278,22 @@ export const addCommand = createSubcommand({
 			});
 
 			tui.success(`SSH key added: ${tui.muted(result.fingerprint)}`);
+
+			return {
+				success: true,
+				fingerprint: result.fingerprint,
+				keyType: publicKey.trim().split(/\s+/)[0] || 'unknown',
+				added: 1,
+			};
 		} catch (error) {
 			logger.trace(error);
 			if (error instanceof Error) {
-				logger.fatal(`Failed to add SSH key: ${error.message}`, ErrorCode.API_ERROR);
+				return logger.fatal(
+					`Failed to add SSH key: ${error.message}`,
+					ErrorCode.API_ERROR
+				) as never;
 			} else {
-				logger.fatal('Failed to add SSH key', ErrorCode.API_ERROR);
+				return logger.fatal('Failed to add SSH key', ErrorCode.API_ERROR) as never;
 			}
 		}
 	},

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

@@ -39,7 +39,7 @@ export const deleteCommand = createSubcommand({
 		const { logger, apiClient, args, opts, options } = ctx;
 
 		if (!apiClient) {
-			logger.fatal('API client is not available', ErrorCode.INTERNAL_ERROR);
+			return logger.fatal('API client is not available', ErrorCode.INTERNAL_ERROR) as never;
 		}
 
 		const shouldConfirm = process.stdin.isTTY ? opts.confirm : false;
@@ -53,15 +53,17 @@ export const deleteCommand = createSubcommand({
 				const keys = await tui.spinner('Fetching SSH keys...', () => listSSHKeys(apiClient));
 
 				if (keys.length === 0) {
-					tui.newline();
-					tui.info('No SSH keys found');
-					return;
+					if (!options.json) {
+						tui.newline();
+						tui.info('No SSH keys found');
+					}
+					return { success: false, removed: 0, fingerprints: [] };
 				}
 
 				if (!process.stdin.isTTY) {
-					logger.fatal(
+					return logger.fatal(
 						'Interactive selection required but cannot prompt in non-TTY environment. Provide fingerprint as argument.'
-					);
+					) as never;
 				}
 
 				tui.newline();
@@ -79,9 +81,11 @@ export const deleteCommand = createSubcommand({
 				fingerprintsToRemove = response.keys;
 
 				if (fingerprintsToRemove.length === 0) {
-					tui.newline();
-					tui.info('No keys selected');
-					return;
+					if (!options.json) {
+						tui.newline();
+						tui.info('No keys selected');
+					}
+					return { success: false, removed: 0, fingerprints: [] };
 				}
 			}
 
@@ -98,7 +102,7 @@ export const deleteCommand = createSubcommand({
 					},
 					options
 				);
-				return;
+				return { success: false, removed: 0, fingerprints: [] };
 			}
 
 			if (shouldConfirm) {
@@ -109,8 +113,10 @@ export const deleteCommand = createSubcommand({
 				);
 
 				if (!confirmed) {
-					tui.info('Cancelled');
-					return;
+					if (!options.json) {
+						tui.info('Cancelled');
+					}
+					return { success: false, removed: 0, fingerprints: [] };
 				}
 			}
 
@@ -119,11 +125,13 @@ export const deleteCommand = createSubcommand({
 				for (const fingerprint of fingerprintsToRemove) {
 					outputDryRun(`Would remove SSH key: ${fingerprint}`, options);
 				}
-				tui.newline();
-				tui.info(
-					`[DRY RUN] Would remove ${fingerprintsToRemove.length} SSH key${fingerprintsToRemove.length > 1 ? 's' : ''}`
-				);
-				return;
+				if (!options.json) {
+					tui.newline();
+					tui.info(
+						`[DRY RUN] Would remove ${fingerprintsToRemove.length} SSH key${fingerprintsToRemove.length > 1 ? 's' : ''}`
+					);
+				}
+				return { success: false, removed: 0, fingerprints: [] };
 			}
 
 			// Actually execute the deletion
@@ -133,10 +141,12 @@ export const deleteCommand = createSubcommand({
 				);
 			}
 
-			tui.newline();
-			tui.success(
-				`Removed ${fingerprintsToRemove.length} SSH key${fingerprintsToRemove.length > 1 ? 's' : ''}`
-			);
+			if (!options.json) {
+				tui.newline();
+				tui.success(
+					`Removed ${fingerprintsToRemove.length} SSH key${fingerprintsToRemove.length > 1 ? 's' : ''}`
+				);
+			}
 
 			return {
 				success: true,
@@ -146,9 +156,12 @@ export const deleteCommand = createSubcommand({
 		} catch (error) {
 			logger.trace(error);
 			if (error instanceof Error) {
-				logger.fatal(`Failed to remove SSH key: ${error.message}`, ErrorCode.API_ERROR);
+				return logger.fatal(
+					`Failed to remove SSH key: ${error.message}`,
+					ErrorCode.API_ERROR
+				) as never;
 			} else {
-				logger.fatal('Failed to remove SSH key', ErrorCode.API_ERROR);
+				return logger.fatal('Failed to remove SSH key', ErrorCode.API_ERROR) as never;
 			}
 		}
 	},

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

@@ -7,11 +7,10 @@ import { z } from 'zod';
 
 const SSHListResponseSchema = z.array(
 	z.object({
-		id: z.string().describe('SSH key ID'),
 		fingerprint: z.string().describe('SSH key fingerprint'),
 		keyType: z.string().describe('SSH key type (e.g., ssh-rsa, ssh-ed25519)'),
-		comment: z.string().optional().describe('SSH key comment'),
-		createdAt: z.string().optional().describe('Creation timestamp'),
+		comment: z.string().describe('SSH key comment'),
+		publicKey: z.string().describe('SSH public key'),
 	})
 );
 
@@ -34,7 +33,7 @@ export const listCommand = createSubcommand({
 		const { logger, apiClient, options } = ctx;
 
 		if (!apiClient) {
-			logger.fatal('API client is not available', ErrorCode.INTERNAL_ERROR);
+			return logger.fatal('API client is not available', ErrorCode.INTERNAL_ERROR) as never;
 		}
 
 		try {
@@ -71,9 +70,12 @@ export const listCommand = createSubcommand({
 		} catch (error) {
 			logger.trace(error);
 			if (error instanceof Error) {
-				logger.fatal(`Failed to list SSH keys: ${error.message}`, ErrorCode.API_ERROR);
+				return logger.fatal(
+					`Failed to list SSH keys: ${error.message}`,
+					ErrorCode.API_ERROR
+				) as never;
 			} else {
-				logger.fatal('Failed to list SSH keys', ErrorCode.API_ERROR);
+				return logger.fatal('Failed to list SSH keys', ErrorCode.API_ERROR) as never;
 			}
 		}
 	},

package/src/cmd/build/ast.ts

@@ -897,3 +897,206 @@ export async function parseRoute(
 	}
 	return routes;
 }
+
+/**
+ * Configuration extracted from createWorkbench call
+ */
+export interface WorkbenchConfig {
+	route: string;
+	headers?: Record<string, string>;
+}
+
+/**
+ * Result of workbench analysis
+ */
+export interface WorkbenchAnalysis {
+	hasWorkbench: boolean;
+	config: WorkbenchConfig | null;
+}
+
+/**
+ * Check if a TypeScript file actively uses a specific function
+ * (ignores comments and unused imports)
+ *
+ * @param content - The TypeScript source code
+ * @param functionName - The function name to check for (e.g., 'createWorkbench')
+ * @returns true if the function is both imported and called
+ */
+export async function checkFunctionUsage(content: string, functionName: string): Promise<boolean> {
+	try {
+		const ts = await import('typescript');
+		const sourceFile = ts.createSourceFile('temp.ts', content, ts.ScriptTarget.Latest, true);
+
+		let hasImport = false;
+		let hasUsage = false;
+
+		function visitNode(node: import('typescript').Node): void {
+			// Check for import declarations with the function
+			if (ts.isImportDeclaration(node) && node.importClause?.namedBindings) {
+				if (ts.isNamedImports(node.importClause.namedBindings)) {
+					for (const element of node.importClause.namedBindings.elements) {
+						if (element.name.text === functionName) {
+							hasImport = true;
+						}
+					}
+				}
+			}
+			// Check for function calls
+			if (ts.isCallExpression(node) && ts.isIdentifier(node.expression)) {
+				if (node.expression.text === functionName) {
+					hasUsage = true;
+				}
+			}
+			// Recursively visit child nodes
+			ts.forEachChild(node, visitNode);
+		}
+
+		visitNode(sourceFile);
+		// Only return true if both import and usage are present
+		return hasImport && hasUsage;
+	} catch (error) {
+		// Fallback to string check if AST parsing fails
+		console.warn(`AST parsing failed for ${functionName}, falling back to string check:`, error);
+		return content.includes(functionName);
+	}
+}
+
+/**
+ * Check if app.ts contains conflicting routes for a given endpoint
+ */
+export async function checkRouteConflicts(
+	content: string,
+	workbenchEndpoint: string
+): Promise<boolean> {
+	try {
+		const ts = await import('typescript');
+		const sourceFile = ts.createSourceFile('app.ts', content, ts.ScriptTarget.Latest, true);
+
+		let hasConflict = false;
+
+		function visitNode(node: import('typescript').Node): void {
+			// Check for router.get calls
+			if (
+				ts.isCallExpression(node) &&
+				ts.isPropertyAccessExpression(node.expression) &&
+				ts.isIdentifier(node.expression.name) &&
+				node.expression.name.text === 'get'
+			) {
+				// Check if first argument is the workbench endpoint
+				if (node.arguments.length > 0 && ts.isStringLiteral(node.arguments[0])) {
+					if (node.arguments[0].text === workbenchEndpoint) {
+						hasConflict = true;
+					}
+				}
+			}
+
+			ts.forEachChild(node, visitNode);
+		}
+
+		visitNode(sourceFile);
+		return hasConflict;
+	} catch (_error) {
+		return false;
+	}
+}
+
+/**
+ * Analyze workbench usage and extract configuration
+ *
+ * @param content - The TypeScript source code
+ * @returns workbench analysis including usage and config
+ */
+export async function analyzeWorkbench(content: string): Promise<WorkbenchAnalysis> {
+	try {
+		const ts = await import('typescript');
+		const sourceFile = ts.createSourceFile('app.ts', content, ts.ScriptTarget.Latest, true);
+
+		let hasImport = false;
+		let hasUsage = false;
+		let config: WorkbenchConfig | null = null;
+
+		function visitNode(node: import('typescript').Node): void {
+			// Check for import declarations with createWorkbench
+			if (ts.isImportDeclaration(node) && node.importClause?.namedBindings) {
+				if (ts.isNamedImports(node.importClause.namedBindings)) {
+					for (const element of node.importClause.namedBindings.elements) {
+						if (element.name.text === 'createWorkbench') {
+							hasImport = true;
+						}
+					}
+				}
+			}
+
+			// Check for createWorkbench function calls and extract config
+			if (ts.isCallExpression(node) && ts.isIdentifier(node.expression)) {
+				if (node.expression.text === 'createWorkbench') {
+					hasUsage = true;
+
+					// Extract configuration from the first argument (if any)
+					if (node.arguments.length > 0) {
+						const configArg = node.arguments[0];
+						config = parseConfigObject(configArg, ts);
+					} else {
+						// Default config if no arguments provided
+						config = { route: '/workbench' };
+					}
+				}
+			}
+
+			// Recursively visit child nodes
+			ts.forEachChild(node, visitNode);
+		}
+
+		visitNode(sourceFile);
+
+		// Set default config if workbench is used but no config was parsed
+		if (hasImport && hasUsage && !config) {
+			config = { route: '/workbench' };
+		}
+
+		return {
+			hasWorkbench: hasImport && hasUsage,
+			config: config,
+		};
+	} catch (error) {
+		// Fallback to simple check if AST parsing fails
+		console.warn('Workbench AST parsing failed, falling back to string check:', error);
+		const hasWorkbench = content.includes('createWorkbench');
+		return {
+			hasWorkbench,
+			config: hasWorkbench ? { route: '/workbench' } : null,
+		};
+	}
+}
+
+/**
+ * Parse a TypeScript object literal to extract configuration
+ */
+function parseConfigObject(
+	node: import('typescript').Node,
+	ts: typeof import('typescript')
+): WorkbenchConfig | null {
+	if (!ts.isObjectLiteralExpression(node)) {
+		return { route: '/workbench' }; // Default config
+	}
+
+	const config: WorkbenchConfig = { route: '/workbench' };
+
+	for (const property of node.properties) {
+		if (ts.isPropertyAssignment(property) && ts.isIdentifier(property.name)) {
+			const propertyName = property.name.text;
+
+			if (propertyName === 'route' && ts.isStringLiteral(property.initializer)) {
+				config.route = property.initializer.text;
+			} else if (
+				propertyName === 'headers' &&
+				ts.isObjectLiteralExpression(property.initializer)
+			) {
+				// Parse headers object if needed (not implemented for now)
+				config.headers = {};
+			}
+		}
+	}
+
+	return config;
+}