@agentuity/cli 0.0.49 → 0.0.51

package/src/cmd/cloud/session/get.ts

@@ -0,0 +1,164 @@
+import { z } from 'zod';
+import { createSubcommand } from '../../../types';
+import * as tui from '../../../tui';
+import { sessionGet } from '@agentuity/server';
+import { getCommand } from '../../../command-prefix';
+import { ErrorCode } from '../../../errors';
+import { getCatalystAPIClient } from '../../../config';
+
+const SessionGetResponseSchema = z.object({
+	id: z.string().describe('Session ID'),
+	created_at: z.string().describe('Creation timestamp'),
+	start_time: z.string().describe('Start time'),
+	end_time: z.string().nullable().describe('End time'),
+	duration: z.number().nullable().describe('Duration in nanoseconds'),
+	org_id: z.string().describe('Organization ID'),
+	project_id: z.string().describe('Project ID'),
+	deployment_id: z.string().describe('Deployment ID'),
+	agent_ids: z.array(z.string()).describe('Agent IDs'),
+	trigger: z.string().describe('Trigger type'),
+	env: z.string().describe('Environment'),
+	devmode: z.boolean().describe('Dev mode'),
+	pending: z.boolean().describe('Pending'),
+	success: z.boolean().describe('Success'),
+	error: z.string().nullable().describe('Error message'),
+	method: z.string().describe('HTTP method'),
+	url: z.string().describe('Request URL'),
+	route_id: z.string().describe('Route ID'),
+	thread_id: z.string().describe('Thread ID'),
+	agentNames: z.array(z.string()).describe('Agent names'),
+	evalRuns: z.array(z.object({
+		id: z.string(),
+		created_at: z.string(),
+		eval_id: z.string(),
+		pending: z.boolean(),
+		success: z.boolean(),
+		error: z.string().nullable(),
+		result: z.string().nullable(),
+	})).describe('Eval runs'),
+});
+
+export const getSubcommand = createSubcommand({
+	name: 'get',
+	description: 'Get details about a specific session',
+	tags: ['read-only', 'fast', 'requires-auth'],
+	examples: [`${getCommand('cloud session get')} sess_abc123xyz`],
+	requires: { auth: true },
+	idempotent: true,
+	schema: {
+		args: z.object({
+			session_id: z.string().describe('Session ID'),
+		}),
+		response: SessionGetResponseSchema,
+	},
+	async handler(ctx) {
+		const { config, logger, auth, args, options } = ctx;
+		const catalystClient = getCatalystAPIClient(config, logger, auth);
+
+		try {
+			const enriched = await sessionGet(catalystClient, { id: args.session_id });
+			const session = enriched.session;
+
+			const result = {
+				id: session.id,
+				created_at: session.created_at,
+				start_time: session.start_time,
+				end_time: session.end_time,
+				duration: session.duration,
+				org_id: session.org_id,
+				project_id: session.project_id,
+				deployment_id: session.deployment_id,
+				agent_ids: session.agent_ids,
+				trigger: session.trigger,
+				env: session.env,
+				devmode: session.devmode,
+				pending: session.pending,
+				success: session.success,
+				error: session.error,
+				method: session.method,
+				url: session.url,
+				route_id: session.route_id,
+				thread_id: session.thread_id,
+				agentNames: enriched.agentNames,
+				evalRuns: enriched.evalRuns.map(run => ({
+					id: run.id,
+					eval_id: run.eval_id,
+					created_at: run.created_at,
+					pending: run.pending,
+					success: run.success,
+					error: run.error,
+					result: run.result,
+				})),
+			};
+
+			if (options.json) {
+				console.log(JSON.stringify(result, null, 2));
+				return result;
+			}
+
+			tui.banner(`Session ${session.id}`, `Status: ${session.success ? 'Success' : 'Failed'}`);
+
+			console.log(tui.bold('ID:          ') + session.id);
+			console.log(tui.bold('Project:     ') + session.project_id);
+			console.log(tui.bold('Deployment:  ') + (session.deployment_id || '-'));
+			console.log(tui.bold('Created:     ') + new Date(session.created_at).toLocaleString());
+			console.log(tui.bold('Start:       ') + new Date(session.start_time).toLocaleString());
+			if (session.end_time) {
+				console.log(tui.bold('End:         ') + new Date(session.end_time).toLocaleString());
+			}
+			if (session.duration) {
+				console.log(
+					tui.bold('Duration:    ') + `${(session.duration / 1_000_000).toFixed(0)}ms`
+				);
+			}
+			console.log(tui.bold('Method:      ') + session.method);
+			console.log(tui.bold('URL:         ') + tui.link(session.url, session.url));
+			console.log(tui.bold('Trigger:     ') + session.trigger);
+			console.log(tui.bold('Environment: ') + session.env);
+			console.log(tui.bold('Dev Mode:    ') + (session.devmode ? 'Yes' : 'No'));
+			console.log(tui.bold('Success:     ') + (session.success ? '✓' : '✗'));
+			console.log(tui.bold('Pending:     ') + (session.pending ? 'Yes' : 'No'));
+			if (session.error) {
+				console.log(tui.bold('Error:       ') + tui.error(session.error));
+			}
+			if (enriched.agentNames.length > 0) {
+				const agentDisplay = enriched.agentNames.map((name, idx) => {
+					const agentId = session.agent_ids[idx];
+					return `${name} ${tui.muted(`(${agentId})`)}`;
+				}).join(', ');
+				console.log(tui.bold('Agents:      ') + agentDisplay);
+			}
+			console.log(tui.bold('Route ID:    ') + session.route_id);
+			console.log(tui.bold('Thread ID:   ') + session.thread_id);
+
+			if (enriched.evalRuns.length > 0) {
+				console.log('');
+				console.log(tui.bold('Eval Runs:'));
+				const evalTableData = enriched.evalRuns.map((run) => ({
+					ID: run.id,
+					'Eval ID': run.eval_id,
+					Success: run.success ? '✓' : '✗',
+					Pending: run.pending ? '⏳' : '✓',
+					Error: run.error || 'No',
+					Created: new Date(run.created_at).toLocaleString(),
+				}));
+
+				tui.table(evalTableData, [
+					{ name: 'ID', alignment: 'left' },
+					{ name: 'Eval ID', alignment: 'left' },
+					{ name: 'Success', alignment: 'center' },
+					{ name: 'Pending', alignment: 'center' },
+					{ name: 'Error', alignment: 'left' },
+					{ name: 'Created', alignment: 'left' },
+				]);
+			}
+
+			return result;
+		} catch (ex) {
+			tui.fatal(
+				`Failed to get session: ${ex instanceof Error ? ex.message : String(ex)}`,
+				ErrorCode.API_ERROR
+			);
+		}
+	},
+});

package/src/cmd/cloud/session/index.ts

@@ -0,0 +1,11 @@
+import { createCommand } from '../../../types';
+import { getSubcommand } from './get';
+import { listSubcommand } from './list';
+import { logsSubcommand } from './logs';
+
+export const sessionCommand = createCommand({
+	name: 'session',
+	description: 'Manage sessions',
+	tags: ['requires-auth'],
+	subcommands: [getSubcommand, listSubcommand, logsSubcommand],
+});

package/src/cmd/cloud/session/list.ts

@@ -0,0 +1,145 @@
+import { z } from 'zod';
+import { createSubcommand } from '../../../types';
+import * as tui from '../../../tui';
+import { sessionList } from '@agentuity/server';
+import { getCommand } from '../../../command-prefix';
+import { ErrorCode } from '../../../errors';
+import { getCatalystAPIClient } from '../../../config';
+
+const SessionListResponseSchema = z.array(
+	z.object({
+		id: z.string().describe('Session ID'),
+		created_at: z.string().describe('Creation timestamp'),
+		success: z.boolean().describe('Whether the session succeeded'),
+		duration: z.number().nullable().describe('Duration in nanoseconds'),
+		method: z.string().describe('HTTP method'),
+		url: z.string().describe('Request URL'),
+		trigger: z.string().describe('Trigger type'),
+		env: z.string().describe('Environment'),
+	})
+);
+
+export const listSubcommand = createSubcommand({
+	name: 'list',
+	description: 'List recent sessions',
+	tags: ['read-only', 'fast', 'requires-auth'],
+	examples: [
+		`${getCommand('cloud session list')}                      # List 10 most recent sessions`,
+		`${getCommand('cloud session list')} --count=25           # List 25 most recent sessions`,
+		`${getCommand('cloud session list')} --project-id=proj_* # Filter by project`,
+		`${getCommand('cloud session list')} --deployment-id=*   # Filter by deployment`,
+		`${getCommand('cloud session list')} --success=true      # Only successful sessions`,
+		`${getCommand('cloud session list')} --devmode=false     # Only production sessions`,
+		`${getCommand('cloud session list')} --trigger=api       # Only API triggered sessions`,
+		`${getCommand('cloud session list')} --env=production    # Only production environment`,
+	],
+	aliases: ['ls'],
+	requires: { auth: true },
+	optional: { project: true },
+	idempotent: true,
+	pagination: {
+		supported: true,
+		defaultLimit: 10,
+		maxLimit: 100,
+		parameters: {
+			limit: 'count',
+		},
+	},
+	schema: {
+		options: z.object({
+			count: z.coerce
+				.number()
+				.int()
+				.min(1)
+				.max(100)
+				.default(10)
+				.describe('Number of sessions to list (1–100)'),
+			projectId: z.string().optional().describe('Filter by project ID'),
+			deploymentId: z.string().optional().describe('Filter by deployment ID'),
+			trigger: z.string().optional().describe('Filter by trigger type (api, cron, webhook)'),
+			env: z.string().optional().describe('Filter by environment'),
+			threadId: z.string().optional().describe('Filter by thread ID'),
+			agentIdentifier: z.string().optional().describe('Filter by agent identifier'),
+			devmode: z.coerce.boolean().optional().describe('Filter by dev mode (true/false)'),
+			success: z.coerce.boolean().optional().describe('Filter by success status (true/false)'),
+			startAfter: z.string().optional().describe('Filter by start time after (ISO 8601)'),
+			startBefore: z.string().optional().describe('Filter by start time before (ISO 8601)'),
+		}),
+		response: SessionListResponseSchema,
+	},
+	async handler(ctx) {
+		const { config, logger, auth, project, opts, options } = ctx;
+		const catalystClient = getCatalystAPIClient(config, logger, auth);
+		
+		const projectId = opts.projectId || project?.projectId;
+
+		try {
+			const sessions = await sessionList(catalystClient, {
+				count: opts.count,
+				projectId,
+				deploymentId: opts.deploymentId,
+				trigger: opts.trigger,
+				env: opts.env,
+				devmode: opts.devmode,
+				success: opts.success,
+				threadId: opts.threadId,
+				agentIdentifier: opts.agentIdentifier,
+				startAfter: opts.startAfter,
+				startBefore: opts.startBefore,
+			});
+
+			const result = sessions.map((s) => ({
+				id: s.id,
+				created_at: s.created_at,
+				success: s.success,
+				duration: s.duration,
+				method: s.method,
+				url: s.url,
+				trigger: s.trigger,
+				env: s.env,
+			}));
+
+			if (options.json) {
+				console.log(JSON.stringify(result, null, 2));
+				return result;
+			}
+
+			if (sessions.length === 0) {
+				tui.info('No sessions found.');
+				return [];
+			}
+
+			const tableData = sessions.map((s) => {
+				const urlPath = new URL(s.url).pathname;
+				return {
+					ID: s.id,
+					Created: new Date(s.created_at).toLocaleString(),
+					Success: s.success ? '✓' : '✗',
+					Duration: s.duration ? `${(s.duration / 1_000_000).toFixed(0)}ms` : '-',
+					Method: s.method,
+					Path: urlPath.length > 50 ? urlPath.substring(0, 47) + '...' : urlPath,
+					Trigger: s.trigger,
+					Env: s.env,
+				};
+			});
+
+			tui.table(tableData, [
+				{ name: 'ID', alignment: 'left' },
+				{ name: 'Created', alignment: 'left' },
+				{ name: 'Success', alignment: 'center' },
+				{ name: 'Duration', alignment: 'right' },
+				{ name: 'Method', alignment: 'left' },
+				{ name: 'Path', alignment: 'left' },
+				{ name: 'Trigger', alignment: 'left' },
+				{ name: 'Env', alignment: 'left' },
+			]);
+
+			return result;
+		} catch (ex) {
+			tui.fatal(
+				`Failed to list sessions: ${ex instanceof Error ? ex.message : String(ex)}`,
+				ErrorCode.API_ERROR
+			);
+		}
+	},
+});

package/src/cmd/cloud/session/logs.ts

@@ -0,0 +1,68 @@
+import { z } from 'zod';
+import { createSubcommand } from '../../../types';
+import * as tui from '../../../tui';
+import { sessionLogs } from '@agentuity/server';
+import { getCommand } from '../../../command-prefix';
+import { ErrorCode } from '../../../errors';
+
+const SessionLogsResponseSchema = z.array(
+	z.object({
+		body: z.string().describe('Log body'),
+		severity: z.string().describe('Log severity'),
+		timestamp: z.string().describe('Log timestamp'),
+	})
+);
+
+export const logsSubcommand = createSubcommand({
+	name: 'logs',
+	description: 'Get logs for a specific session',
+	tags: ['read-only', 'slow', 'requires-auth'],
+	examples: [`${getCommand('cloud session logs')} sess_abc123xyz`],
+	requires: { auth: true, apiClient: true },
+	optional: { project: true },
+	idempotent: true,
+	schema: {
+		args: z.object({
+			session_id: z.string().describe('Session ID'),
+		}),
+		options: z.object({
+			projectId: z.string().optional().describe('Project ID (for display purposes)'),
+			deploymentId: z.string().optional().describe('Deployment ID (for display purposes)'),
+		}),
+		response: SessionLogsResponseSchema,
+	},
+	async handler(ctx) {
+		const { apiClient, args } = ctx;
+
+		try {
+			const logs = await sessionLogs(apiClient, { id: args.session_id });
+
+			if (logs.length === 0) {
+				tui.info('No logs found for this session.');
+				return [];
+			}
+
+			tui.banner(`Logs for Session ${args.session_id}`, `${logs.length} log entries`);
+
+			for (const log of logs) {
+				const timestamp = new Date(log.timestamp).toLocaleTimeString();
+				const severity = log.severity.padEnd(5);
+				const severityColor =
+					log.severity === 'ERROR'
+						? tui.error(severity)
+						: log.severity === 'WARN'
+							? tui.warning(severity)
+							: tui.muted(severity);
+
+				console.log(`${tui.muted(timestamp)} ${severityColor} ${log.body}`);
+			}
+
+			return logs;
+		} catch (ex) {
+			tui.fatal(
+				`Failed to get session logs: ${ex instanceof Error ? ex.message : String(ex)}`,
+				ErrorCode.API_ERROR
+			);
+		}
+	},
+});

package/src/cmd/dev/agents.ts

@@ -0,0 +1,122 @@
+import { z } from 'zod';
+import { createSubcommand } from '../../types';
+import * as tui from '../../tui';
+import { APIResponseSchema } from '@agentuity/server';
+import { abbreviate, abbreviateDescription } from '../../utils/format';
+
+const AgentSchema = z.object({
+	id: z.string(),
+	name: z.string(),
+	description: z.string().nullable(),
+	identifier: z.string(),
+	version: z.string().nullable(),
+	deploymentId: z.string().nullable(),
+	devmode: z.boolean(),
+	metadata: z.record(z.string(), z.unknown()).nullable(),
+	createdAt: z.string(),
+	updatedAt: z.string(),
+	evals: z.array(
+		z.object({
+			id: z.string(),
+			name: z.string(),
+			description: z.string().nullable(),
+			identifier: z.string().nullable(),
+			deploymentId: z.string().nullable(),
+			version: z.string().nullable(),
+			devmode: z.boolean(),
+			createdAt: z.string(),
+			updatedAt: z.string(),
+		})
+	),
+});
+
+const AgentsResponseSchema = APIResponseSchema(z.array(AgentSchema));
+
+export const agentsSubcommand = createSubcommand({
+	name: 'agents',
+	description: 'Show devmode agent results',
+	requires: { auth: true, apiClient: true, project: true },
+	schema: {
+		options: z.object({
+			deploymentId: z.string().optional().describe('Filter by deployment ID'),
+			format: z
+				.enum(['json', 'table'])
+				.optional()
+				.default('table')
+				.describe('Output format: json or table'),
+			verbose: z.boolean().optional().default(false).describe('Show full IDs and descriptions'),
+		}),
+	},
+	async handler(ctx) {
+		const { opts, apiClient, project } = ctx;
+		const projectId = project.projectId;
+		const format = opts?.format ?? 'table';
+		const verbose = opts?.verbose ?? false;
+
+		const deploymentId = opts?.deploymentId;
+		const queryParams = deploymentId ? `?deploymentId=${deploymentId}` : '';
+		const response = await tui.spinner('Fetching agents', async () => {
+			return apiClient.request(
+				'GET',
+				`/cli/agent/${projectId}${queryParams}`,
+				AgentsResponseSchema
+			);
+		});
+
+		if (!response.success) {
+			tui.fatal(`Failed to fetch agents: ${response.message ?? 'Unknown error'}`);
+		}
+
+		const agents = response.data;
+
+		if (format === 'json') {
+			console.log(JSON.stringify(agents, null, 2));
+			return;
+		}
+
+		tui.info(`Agents (${agents.length})`);
+		if (agents.length === 0) {
+			tui.muted('No agents found');
+		} else {
+			console.table(
+				agents.map((agent) => ({
+					name: agent.name,
+					id: verbose ? agent.id : abbreviate(agent.id, 20),
+					identifier: verbose ? agent.identifier : abbreviate(agent.identifier, 20),
+					deployment: abbreviate(agent.deploymentId, 20),
+					version: verbose
+						? (agent.version ?? 'N/A')
+						: (abbreviate(agent.version, 20) ?? 'N/A'),
+					evals: agent.evals.length,
+					createdAt: new Date(agent.createdAt).toLocaleString(),
+				})),
+				['name', 'id', 'identifier', 'deployment', 'version', 'evals', 'createdAt']
+			);
+
+			// Show evals for each agent
+			for (const agent of agents) {
+				if (agent.evals.length > 0) {
+					console.log(`\n  Evals for ${agent.name}:`);
+					console.table(
+						agent.evals.map((evalItem) => ({
+							name: evalItem.name,
+							id: verbose ? evalItem.id : abbreviate(evalItem.id, 20),
+							identifier: verbose
+								? (evalItem.identifier ?? 'N/A')
+								: (abbreviate(evalItem.identifier, 20) ?? 'N/A'),
+							deployment: abbreviate(evalItem.deploymentId, 20),
+							version: verbose
+								? (evalItem.version ?? 'N/A')
+								: (abbreviate(evalItem.version, 20) ?? 'N/A'),
+							description: verbose
+								? (evalItem.description ?? 'N/A')
+								: abbreviateDescription(evalItem.description),
+							createdAt: new Date(evalItem.createdAt).toLocaleString(),
+						})),
+						['name', 'id', 'identifier', 'deployment', 'version', 'description', 'createdAt']
+					);
+				}
+			}
+		}
+	},
+});

package/src/cmd/dev/index.ts

@@ -1,17 +1,25 @@
 /** biome-ignore-all lint/style/useTemplate: its easier */
 import { z } from 'zod';
-import type { BuildMetadata } from '@agentuity/server';
 import { resolve, join } from 'node:path';
-import { bundle } from '../bundle/bundler';
-import { getBuildMetadata } from '../bundle/plugin';
+import { bundle } from '../build/bundler';
+import { getBuildMetadata } from '../build/plugin';
 import { existsSync, type FSWatcher, watch, statSync, readdirSync } from 'node:fs';
-import { getDefaultConfigDir, loadProjectSDKKey, saveProjectDir, saveConfig } from '../../config';
+import {
+	getDefaultConfigDir,
+	loadProjectSDKKey,
+	saveProjectDir,
+	saveConfig,
+	loadBuildMetadata,
+} from '../../config';
 import { type Config, createCommand } from '../../types';
 import * as tui from '../../tui';
 import { createAgentTemplates, createAPITemplates } from './templates';
 import { generateEndpoint, type DevmodeResponse } from './api';
 import { APIClient, getAPIBaseURL } from '../../api';
 import { download } from './download';
+import { createDevmodeSyncService } from './sync';
+import { getDevmodeDeploymentId } from '../build/ast';
+import { BuildMetadata } from '@agentuity/server';
 import { getCommand } from '../../command-prefix';
 
 export const command = createCommand({
@@ -47,6 +55,11 @@ export const command = createCommand({
 		const { opts, logger, options, project, projectDir, auth } = ctx;
 		let { config } = ctx;
 
+		// Allow sync with mock service even without devmode endpoint
+		const useMockService = process.env.DEVMODE_SYNC_SERVICE_MOCK === 'true';
+		const apiClient = new APIClient(getAPIBaseURL(config), logger, config);
+		const syncService = createDevmodeSyncService({ logger, apiClient, mock: useMockService });
+
 		const rootDir = projectDir;
 		const appTs = join(rootDir, 'app.ts');
 		const srcDir = join(rootDir, 'src');
@@ -73,12 +86,11 @@ export const command = createCommand({
 		let gravityBin: string | undefined;
 
 		if (auth && project && opts.public) {
-			// Only create apiClient if auth is available
-			const apiClient = new APIClient(getAPIBaseURL(config), logger, config);
+			// Generate devmode endpoint only when using --public
 			const endpoint = await tui.spinner({
 				message: 'Connecting to Gravity',
 				callback: () => {
-					return generateEndpoint(apiClient, project.projectId, config?.devmode?.hostname);
+					return generateEndpoint(apiClient!, project.projectId, config?.devmode?.hostname);
 				},
 				clearOnSuccess: true,
 			});
@@ -91,6 +103,13 @@ export const command = createCommand({
 			devmode = endpoint;
 		}
 
+		logger.debug(
+			'Getting devmode deployment id for projectId: %s, endpointId: %s',
+			project?.projectId,
+			devmode?.id
+		);
+		const deploymentId = getDevmodeDeploymentId(project?.projectId ?? '', devmode?.id ?? '');
+
 		if (devmode) {
 			const configDir = getDefaultConfigDir();
 			const gravityDir = join(configDir, 'gravity');
@@ -183,6 +202,21 @@ export const command = createCommand({
 		const agentuityDir = resolve(rootDir, '.agentuity');
 		const appPath = resolve(agentuityDir, 'app.js');
 
+		// Load existing metadata file to use as previousMetadata for sync
+		// This prevents reinserting agents/evals that haven't changed
+		let previousMetadata: BuildMetadata | undefined;
+		try {
+			previousMetadata = await loadBuildMetadata(agentuityDir);
+			logger.debug(
+				'Loaded previous metadata with %d agent(s)',
+				previousMetadata.agents?.length ?? 0
+			);
+		} catch (_error) {
+			// File doesn't exist yet (first run), that's okay
+			logger.debug('No previous metadata file found, will treat all agents/evals as new');
+			previousMetadata = undefined;
+		}
+
 		// Watch directories instead of files to survive atomic replacements (sed -i, cp)
 		const watches = [rootDir];
 		const watchers: FSWatcher[] = [];
@@ -394,6 +428,8 @@ export const command = createCommand({
 							await bundle({
 								rootDir,
 								dev: true,
+								projectId: project?.projectId,
+								deploymentId,
 							});
 							building = false;
 							buildCompletedAt = Date.now();
@@ -423,6 +459,64 @@ export const command = createCommand({
 				metadata = getBuildMetadata();
 				logger.trace('Build metadata retrieved');
 
+				// Sync agents and evals to API if in devmode with auth
+				if (auth && project && apiClient) {
+					try {
+						logger.debug('Loading build metadata for sync...');
+						const currentMetadata = await loadBuildMetadata(agentuityDir);
+						logger.debug(
+							'Found %d agent(s) and %d route(s) in metadata',
+							currentMetadata.agents?.length ?? 0,
+							currentMetadata.routes?.length ?? 0
+						);
+						if (currentMetadata.agents) {
+							for (const agent of currentMetadata.agents) {
+								logger.debug(
+									'Agent: id=%s, name=%s, version=%s, evals=%d',
+									agent.id,
+									agent.name,
+									agent.version,
+									agent.evals?.length ?? 0
+								);
+								if (agent.evals) {
+									for (const evalItem of agent.evals) {
+										logger.debug(
+											'  Eval: id=%s, name=%s, version=%s',
+											evalItem.id,
+											evalItem.name,
+											evalItem.version
+										);
+									}
+								}
+							}
+						}
+						logger.debug('Syncing agents and evals...');
+
+						await syncService.sync(
+							currentMetadata,
+							previousMetadata,
+							project.projectId,
+							deploymentId
+						);
+						previousMetadata = currentMetadata;
+						logger.debug('Sync completed successfully');
+					} catch (error) {
+						logger.error('Failed to sync agents/evals: %s', error);
+						if (error instanceof Error) {
+							logger.error('Error stack: %s', error.stack);
+						}
+						// Don't fail the build, just log the error
+					}
+				} else {
+					logger.trace(
+						'Skipping sync - auth=%s, project=%s, devmode=%s, apiClient=%s',
+						!!auth,
+						!!project,
+						!!devmode,
+						!!apiClient
+					);
+				}
+
 				logger.trace('Starting dev server: %s', appPath);
 				// Use shell to run in a process group for proper cleanup
 				// The 'exec' ensures the shell is replaced by the actual process
@@ -558,12 +652,12 @@ export const command = createCommand({
 
 			const showRoutes = () => {
 				tui.info('API Route Detail');
-				console.table(metadata?.routes, ['method', 'path', 'filename']);
+				tui.table(metadata?.routes ?? [], ['method', 'path', 'filename']);
 			};
 
 			const showAgents = () => {
 				tui.info('Agent Detail');
-				console.table(metadata?.agents, ['name', 'filename', 'description']);
+				tui.table(metadata?.agents ?? [], ['name', 'filename', 'description']);
 			};
 
 			process.stdin.on('data', (data) => {