@agentuity/cli 0.1.40 → 0.1.42

package/src/cmd/build/ast.ts

@@ -2079,8 +2079,9 @@ export function checkRouteConflicts(content: string, workbenchEndpoint: string):
 				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) {
+				const firstArg = node.arguments[0];
+				if (node.arguments.length > 0 && firstArg && ts.isStringLiteral(firstArg)) {
+					if (firstArg.text === workbenchEndpoint) {
 						hasConflict = true;
 					}
 				}
@@ -2135,8 +2136,8 @@ export function extractAppStateType(content: string): string | null {
 
 			if (callExpr) {
 				// Check if it has a config object argument
-				if (callExpr.arguments.length > 0) {
-					const configArg = callExpr.arguments[0];
+				const configArg = callExpr.arguments[0];
+				if (callExpr.arguments.length > 0 && configArg) {
 					if (ts.isObjectLiteralExpression(configArg)) {
 						// Find setup property
 						for (const prop of configArg.properties) {
@@ -2637,9 +2638,9 @@ export function analyzeWorkbench(content: string): WorkbenchAnalysis {
 				if (ts.isIdentifier(node.name)) {
 					// Extract configuration from the first argument (if any)
 					let varConfig: WorkbenchConfig;
-					if (node.initializer.arguments.length > 0) {
-						const configArg = node.initializer.arguments[0];
-						varConfig = parseConfigObject(configArg) || { route: '/workbench' };
+					const firstInitArg = node.initializer.arguments[0];
+					if (node.initializer.arguments.length > 0 && firstInitArg) {
+						varConfig = parseConfigObject(firstInitArg) || { route: '/workbench' };
 					} else {
 						// Default config if no arguments provided
 						varConfig = { route: '/workbench' };
@@ -2655,10 +2656,10 @@ export function analyzeWorkbench(content: string): WorkbenchAnalysis {
 				node.expression.text === 'createApp' &&
 				node.arguments.length > 0
 			) {
-				const configArg = node.arguments[0];
-				if (ts.isObjectLiteralExpression(configArg)) {
+				const createAppConfigArg = node.arguments[0];
+				if (createAppConfigArg && ts.isObjectLiteralExpression(createAppConfigArg)) {
 					// Find the services property
-					for (const prop of configArg.properties) {
+					for (const prop of createAppConfigArg.properties) {
 						if (
 							ts.isPropertyAssignment(prop) &&
 							ts.isIdentifier(prop.name) &&
@@ -2740,9 +2741,9 @@ export function analyzeWorkbench(content: string): WorkbenchAnalysis {
 						node.expression.text === 'createApp' &&
 						node.arguments.length > 0
 					) {
-						const configArg = node.arguments[0];
-						if (ts.isObjectLiteralExpression(configArg)) {
-							for (const prop of configArg.properties) {
+						const checkConfigArg = node.arguments[0];
+						if (checkConfigArg && ts.isObjectLiteralExpression(checkConfigArg)) {
+							for (const prop of checkConfigArg.properties) {
 								if (
 									ts.isPropertyAssignment(prop) &&
 									ts.isIdentifier(prop.name) &&

package/src/cmd/build/entry-generator.ts

@@ -84,6 +84,7 @@ export async function generateEntryFile(options: GenerateEntryOptions): Promise<
 		`  createWorkbenchRouter,`,
 		`  bootstrapRuntimeEnv,`,
 		`  patchBunS3ForStorageDev,`,
+		`  runShutdown,`,
 	];
 
 	const imports = [
@@ -377,6 +378,24 @@ if (typeof Bun !== 'undefined') {
 	if (isDevelopment() && process.env.VITE_PORT) {
 		otel.logger.debug(\`Proxying Vite assets from port \${process.env.VITE_PORT}\`);
 	}
+
+	// Register signal handlers for graceful shutdown (production only)
+	// Dev mode has its own handlers in devmode.ts
+	if (!isDevelopment()) {
+		const handleShutdown = async (signal: string) => {
+			otel.logger.info(\`Received \${signal}, initiating graceful shutdown...\`);
+			try {
+				await runShutdown();
+				otel.logger.info('Shutdown complete');
+			} catch (err) {
+				otel.logger.error(\`Error during shutdown: \${err instanceof Error ? err.message : String(err)}\`);
+			}
+			process.exit(0);
+		};
+
+		process.once('SIGTERM', () => handleShutdown('SIGTERM'));
+		process.once('SIGINT', () => handleShutdown('SIGINT'));
+	}
 }
 
 // FOUND AN ERROR IN THIS FILE?

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

@@ -27,6 +27,9 @@ export async function applyPatch(
 	if (patch.functions) {
 		for (const fn of Object.keys(patch.functions)) {
 			const mod = patch.functions[fn];
+			if (!mod) {
+				continue;
+			}
 			let fnname = `function ${fn}`;
 			let index = contents.indexOf(fnname);
 			let isConstVariable = false;

package/src/cmd/build/vite/index.ts

@@ -12,6 +12,7 @@ import { loadAgentuityConfig, getWorkbenchConfig } from './config-loader';
 
 // Re-export plugins
 export { browserEnvPlugin } from './browser-env-plugin';
+export { publicAssetPathPlugin } from './public-asset-path-plugin';
 
 export interface AgentuityPluginOptions {
 	dev?: boolean;

package/src/cmd/build/vite/public-asset-path-plugin.ts

@@ -0,0 +1,137 @@
+/**
+ * Vite plugin to fix incorrect public asset paths
+ *
+ * Developers sometimes accidentally use source paths or relative paths instead
+ * of the correct absolute production path '/public/...'. This plugin:
+ *
+ * 1. During build: Rewrites incorrect paths to '/public/*' in the bundle
+ * 2. During dev: Warns about incorrect paths so developers can fix them
+ *
+ * Patterns handled:
+ * - '/src/web/public/...'  → '/public/...'
+ * - './src/web/public/...' → '/public/...'
+ * - 'src/web/public/...'   → '/public/...'
+ * - './public/...'         → '/public/...'
+ */
+
+import type { Plugin } from 'vite';
+
+export interface PublicAssetPathPluginOptions {
+	/** Whether to show warnings in dev mode (default: true) */
+	warnInDev?: boolean;
+}
+
+interface PathPattern {
+	regex: RegExp;
+	description: string;
+}
+
+/**
+ * Create fresh regex instances for each transform call
+ * (RegExp with global flag maintains state via lastIndex)
+ */
+function createPatterns(): PathPattern[] {
+	return [
+		// '/src/web/public/...' or './src/web/public/...' or 'src/web/public/...'
+		{
+			regex: /(['"`])(?:\.?\/)?src\/web\/public\//g,
+			description: 'src/web/public/',
+		},
+		// './public/...' (relative public path - should be absolute)
+		{
+			regex: /(['"`])\.\/public\//g,
+			description: './public/',
+		},
+	];
+}
+
+/**
+ * Vite plugin that fixes incorrect public asset paths
+ *
+ * @example
+ * // In vite config:
+ * plugins: [publicAssetPathPlugin()]
+ *
+ * // Transforms:
+ * // '/src/web/public/logo.svg'  → '/public/logo.svg'
+ * // './src/web/public/logo.svg' → '/public/logo.svg'
+ * // './public/logo.svg'         → '/public/logo.svg'
+ */
+export function publicAssetPathPlugin(options: PublicAssetPathPluginOptions = {}): Plugin {
+	const { warnInDev = true } = options;
+
+	let isDev = false;
+	const warnedFiles = new Map<string, Set<string>>(); // file -> set of patterns warned
+
+	return {
+		name: 'agentuity:public-asset-path',
+
+		configResolved(config) {
+			isDev = config.command === 'serve';
+		},
+
+		transform(code, id) {
+			// Only transform files in src/web (browser code)
+			if (!id.includes('/src/web/') && !id.includes('\\src\\web\\')) {
+				return null;
+			}
+
+			// Quick check: does the code contain any patterns we care about?
+			const hasIncorrectPaths = code.includes('src/web/public/') || code.includes('./public/');
+
+			if (!hasIncorrectPaths) {
+				return null;
+			}
+
+			// Create fresh patterns for this transform
+			const patterns = createPatterns();
+
+			// Track which patterns were found for warnings
+			const foundPatterns: string[] = [];
+			let transformed = code;
+
+			for (const { regex, description } of patterns) {
+				if (regex.test(transformed)) {
+					foundPatterns.push(description);
+
+					// Create a fresh regex for the replacement (test() consumed the previous one)
+					const replaceRegex = new RegExp(regex.source, regex.flags);
+					transformed = transformed.replace(replaceRegex, '$1/public/');
+				}
+			}
+
+			// In dev mode, optionally warn but don't transform (Vite serves from source paths)
+			if (isDev) {
+				if (warnInDev && foundPatterns.length > 0) {
+					const fileWarnings = warnedFiles.get(id) || new Set();
+					const newWarnings = foundPatterns.filter((p) => !fileWarnings.has(p));
+
+					if (newWarnings.length > 0) {
+						for (const p of newWarnings) {
+							fileWarnings.add(p);
+						}
+						warnedFiles.set(id, fileWarnings);
+
+						this.warn(
+							`Found incorrect asset path(s) in ${id}:\n` +
+								newWarnings.map((p) => `  - '${p}' should be '/public/'`).join('\n') +
+								`\nUse absolute '/public/...' paths for production compatibility.`
+						);
+					}
+				}
+				// In dev mode, never transform - Vite serves from source paths
+				return null;
+			}
+
+			// In build mode, return transformed code if changed
+			if (transformed !== code) {
+				return {
+					code: transformed,
+					map: null,
+				};
+			}
+
+			return null;
+		},
+	};
+}

package/src/cmd/build/vite/registry-generator.ts

@@ -374,7 +374,11 @@ function generateRPCRegistryType(
 
 		// Add path segments - sanitize for valid TypeScript property names
 		for (let i = 0; i < pathParts.length; i++) {
-			const part = sanitizePathSegment(pathParts[i]);
+			const rawPart = pathParts[i];
+			if (!rawPart) {
+				continue;
+			}
+			const part = sanitizePathSegment(rawPart);
 			// Skip empty segments (e.g., wildcards like '*' that sanitize to '')
 			if (!part) {
 				continue;
@@ -561,7 +565,10 @@ function generateRPCRuntimeMetadata(
 		const sorted: MetadataNode = {};
 		for (const key of Object.keys(obj).sort()) {
 			const value = obj[key];
-			if (value && typeof value === 'object' && !('type' in value)) {
+			if (value === undefined) {
+				continue;
+			}
+			if (typeof value === 'object' && !('type' in value)) {
 				sorted[key] = sortObject(value as MetadataNode);
 			} else {
 				sorted[key] = value;
@@ -640,9 +647,11 @@ export async function generateRouteRegistry(
 			const match = route.agentImportPath.match(/@agent[s]?\/([^/]+)/);
 			if (match) {
 				const agentName = match[1];
-				const metadata = agentNameMap.get(agentName);
-				if (metadata) {
-					agentMetadataMap.set(route.agentVariable, metadata);
+				if (agentName) {
+					const metadata = agentNameMap.get(agentName);
+					if (metadata) {
+						agentMetadataMap.set(route.agentVariable, metadata);
+					}
 				}
 			}
 		}

package/src/cmd/build/vite/route-discovery.ts

@@ -213,7 +213,7 @@ export function detectRouteConflicts(
 	// Check for exact duplicates
 	for (const [methodPath, routeList] of methodPathMap.entries()) {
 		if (routeList.length > 1) {
-			const [method] = methodPath.split(' ', 2);
+			const [method = 'UNKNOWN'] = methodPath.split(' ', 2);
 			conflicts.push({
 				type: 'duplicate',
 				routes: routeList.map((r) => ({ method, path: r.path, filename: r.filename })),

package/src/cmd/build/vite/vite-asset-server-config.ts

@@ -49,10 +49,16 @@ export async function generateAssetServerConfig(
 		const tsconfig = JSON.parse(await Bun.file(tsconfigPath).text());
 		const paths = tsconfig?.compilerOptions?.paths || {};
 		alias = Object.fromEntries(
-			Object.entries(paths).map(([key, value]) => {
-				const pathArray = value as string[];
-				return [key.replace('/*', ''), join(rootDir, pathArray[0].replace('/*', ''))];
-			})
+			Object.entries(paths)
+				.filter(([, value]) => {
+					const pathArray = value as string[];
+					return pathArray.length > 0 && pathArray[0] !== undefined;
+				})
+				.map(([key, value]) => {
+					const pathArray = value as string[];
+					const firstPath = pathArray[0] ?? '';
+					return [key.replace('/*', ''), join(rootDir, firstPath.replace('/*', ''))];
+				})
 		);
 	} catch {
 		// No tsconfig or no paths - that's fine
@@ -131,6 +137,7 @@ export async function generateAssetServerConfig(
 			}
 			const reactPlugin = (await import(reactPluginPath)).default();
 			const { browserEnvPlugin } = await import('./browser-env-plugin');
+			const { publicAssetPathPlugin } = await import('./public-asset-path-plugin');
 			return [
 				// User-defined plugins from agentuity.config.ts (e.g., Tailwind CSS)
 				...userPlugins,
@@ -138,6 +145,8 @@ export async function generateAssetServerConfig(
 				reactPlugin,
 				// Browser env plugin to map process.env to import.meta.env
 				browserEnvPlugin(),
+				// Warn about incorrect public asset paths in dev mode
+				publicAssetPathPlugin({ warnInDev: true }),
 			];
 		})(),
 

package/src/cmd/build/vite/vite-builder.ts

@@ -11,6 +11,7 @@ import type { InlineConfig, Plugin } from 'vite';
 import type { Logger, DeployOptions } from '../../../types';
 import { browserEnvPlugin } from './browser-env-plugin';
 import { beaconPlugin } from './beacon-plugin';
+import { publicAssetPathPlugin } from './public-asset-path-plugin';
 import type { BuildReportCollector } from '../../../build-report';
 
 /**
@@ -153,6 +154,8 @@ export async function runViteBuild(options: ViteBuildOptions): Promise<void> {
 		const plugins = [
 			react(),
 			browserEnvPlugin(),
+			// Fix incorrect public asset paths (e.g., '/src/web/public/...' → '/public/...')
+			publicAssetPathPlugin(),
 			flattenHtmlOutputPlugin(clientOutDir),
 			// Emit analytics beacon as hashed CDN asset (prod builds only)
 			beaconPlugin({ enabled: analyticsEnabled && !dev }),

package/src/cmd/canary/index.ts

@@ -58,6 +58,14 @@ export const command = createCommand({
 
 		// Get target from parsed args, but get forward args from raw argv
 		const target = args.args[0];
+		if (!target) {
+			tui.error('Usage: agentuity canary <version> [commands...]');
+			return {
+				executed: false,
+				version: '',
+				message: 'No target specified',
+			};
+		}
 		const targetIndex = canaryIndex >= 0 ? argv.indexOf(target, canaryIndex) : -1;
 		const forwardArgs = targetIndex >= 0 ? argv.slice(targetIndex + 1) : args.args.slice(1);
 
@@ -79,7 +87,7 @@ export const command = createCommand({
 			tarballUrl = target;
 			// Extract version from URL if possible
 			const match = target.match(/agentuity-cli-(\d+\.\d+\.\d+-[a-f0-9]+)\.tgz/);
-			version = match ? match[1] : 'custom';
+			version = match?.[1] ?? 'custom';
 		} else {
 			// Version string - construct URL
 			version = target;

package/src/cmd/cloud/db/create.ts

@@ -74,25 +74,24 @@ export const createSubcommand = defineSubcommand({
 					]);
 				},
 			});
-			if (created.length > 0) {
-				const resource = created[0];
-
-				// Write environment variables to .env if running inside a project
-				if (ctx.projectDir && resource.env && Object.keys(resource.env).length > 0) {
-					await addResourceEnvVars(ctx.projectDir, resource.env);
-					if (!options.json) {
-						tui.info('Environment variables written to .env');
-					}
-				}
-
+		const resource = created[0];
+		if (resource) {
+			// Write environment variables to .env if running inside a project
+			if (ctx.projectDir && resource.env && Object.keys(resource.env).length > 0) {
+				await addResourceEnvVars(ctx.projectDir, resource.env);
 				if (!options.json) {
-					tui.success(`Created database: ${tui.bold(resource.name)}`);
+					tui.info('Environment variables written to .env');
 				}
-				return {
-					success: true,
-					name: resource.name,
-				};
-			} else {
+			}
+
+			if (!options.json) {
+				tui.success(`Created database: ${tui.bold(resource.name)}`);
+			}
+			return {
+				success: true,
+				name: resource.name,
+			};
+		} else {
 				tui.fatal('Failed to create database');
 			}
 		} catch (ex) {

package/src/cmd/cloud/db/delete.ts

@@ -178,28 +178,27 @@ export const deleteSubcommand = createSubcommand({
 				},
 			});
 
-			if (deleted.length > 0) {
-				const resource = deleted[0];
-
-				// Clear cache entry for deleted database
-				await deleteResourceRegion('db', profileName, resource.name);
-
-				// Remove env vars from .env if running inside a project
-				if (ctx.projectDir && resource.env_keys.length > 0) {
-					await removeResourceEnvVars(ctx.projectDir, resource.env_keys);
-					if (!options.json) {
-						tui.info(`Removed ${resource.env_keys.join(', ')} from .env`);
-					}
-				}
-
+		const resource = deleted[0];
+		if (resource) {
+			// Clear cache entry for deleted database
+			await deleteResourceRegion('db', profileName, resource.name);
+
+			// Remove env vars from .env if running inside a project
+			if (ctx.projectDir && resource.env_keys.length > 0) {
+				await removeResourceEnvVars(ctx.projectDir, resource.env_keys);
 				if (!options.json) {
-					tui.success(`Deleted database: ${tui.bold(resource.name)}`);
+					tui.info(`Removed ${resource.env_keys.join(', ')} from .env`);
 				}
-				return {
-					success: true,
-					name: resource.name,
-				};
-			} else {
+			}
+
+			if (!options.json) {
+				tui.success(`Deleted database: ${tui.bold(resource.name)}`);
+			}
+			return {
+				success: true,
+				name: resource.name,
+			};
+		} else {
 				tui.error('Failed to delete database');
 				return { success: false, name: dbName };
 			}

package/src/cmd/cloud/deploy-fork.ts

@@ -75,6 +75,77 @@ export async function runForkedDeploy(options: ForkDeployOptions): Promise<ForkD
 	const cleanLogsFile = join(tmpdir(), `agentuity-deploy-${deploymentId}-logs.txt`);
 	let outputBuffer = '';
 	let proc: Subprocess | null = null;
+	let cancelled = false;
+
+	// Signal handler to forward signals to child process and report cancellation
+	const handleSignal = async (signal: NodeJS.Signals) => {
+		if (cancelled) return;
+		cancelled = true;
+
+		logger.debug('Received %s, forwarding to child process', signal);
+
+		// Kill the child process if it's still running
+		if (proc && proc.exitCode === null) {
+			try {
+				proc.kill(signal);
+			} catch (err) {
+				logger.debug('Failed to kill child process: %s', err);
+			}
+		}
+
+		// Report deployment as cancelled (with timeout to ensure prompt exit)
+		const cancelMessage = 'Deployment cancelled by user';
+		const timeoutMs = 3000; // 3 second timeout
+		const timeoutPromise = new Promise<void>((resolve) => {
+			setTimeout(() => {
+				logger.debug('API call to report cancellation timed out after %dms', timeoutMs);
+				resolve();
+			}, timeoutMs);
+		});
+
+		const apiCallPromise = projectDeploymentFail(apiClient, deploymentId, {
+			error: cancelMessage,
+			diagnostics: {
+				success: false,
+				errors: [
+					{
+						type: 'general',
+						scope: 'deploy',
+						message: cancelMessage,
+						code: 'DEPLOY_CANCELLED',
+					},
+				],
+				warnings: [],
+				diagnostics: [],
+				error: cancelMessage,
+			},
+		}).catch((err) => {
+			logger.debug('Failed to report cancellation: %s', err);
+		});
+
+		// Race API call against timeout to ensure prompt exit
+		await Promise.race([apiCallPromise, timeoutPromise]);
+
+		// Exit with signal-specific exit code
+		const signalExitCodes: Record<string, number> = {
+			SIGINT: 130, // 128 + 2
+			SIGTERM: 143, // 128 + 15
+			SIGHUP: 129, // 128 + 1
+			SIGQUIT: 131, // 128 + 3
+		};
+		const exitCode = signalExitCodes[signal] ?? 128;
+		process.exit(exitCode);
+	};
+
+	// Install signal handlers
+	const sigintHandler = () => {
+		void handleSignal('SIGINT');
+	};
+	const sigtermHandler = () => {
+		void handleSignal('SIGTERM');
+	};
+	process.on('SIGINT', sigintHandler);
+	process.on('SIGTERM', sigtermHandler);
 
 	try {
 		const childArgs = [
@@ -282,6 +353,10 @@ export async function runForkedDeploy(options: ForkDeployOptions): Promise<ForkD
 			},
 		};
 	} finally {
+		// Clean up signal handlers
+		process.off('SIGINT', sigintHandler);
+		process.off('SIGTERM', sigtermHandler);
+
 		// Clean up temp files
 		for (const file of [reportFile, cleanLogsFile]) {
 			if (existsSync(file)) {

package/src/cmd/cloud/env/import.ts

@@ -113,11 +113,14 @@ export const importSubcommand = createSubcommand({
 			tui.warning(
 				`Moving public variables to env: ${publicSecretKeys.join(', ')} (these are exposed to the frontend)`
 			);
-			for (const key of publicSecretKeys) {
-				delete secrets[key];
-				env[key] = filteredVars[key];
+		for (const key of publicSecretKeys) {
+			delete secrets[key];
+			const value = filteredVars[key];
+			if (value !== undefined) {
+				env[key] = value;
 			}
 		}
+		}
 
 		const envCount = Object.keys(env).length;
 		const secretCount = Object.keys(secrets).length;

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

@@ -168,15 +168,17 @@ export const listSubcommand = createSubcommand({
 				const sortedKeys = Object.keys(result).sort();
 				const shouldMask = opts?.mask !== false;
 
-				for (const key of sortedKeys) {
-					const { value, secret, scope } = result[key];
-					const displayValue = shouldMask && secret ? tui.maskSecret(value) : value;
-					const typeIndicator = secret ? ' [secret]' : '';
-					const scopeIndicator = !useOrgScope ? ` [${scope}]` : '';
-					console.log(
-						`${tui.bold(key)}=${displayValue}${tui.muted(typeIndicator + scopeIndicator)}`
-					);
-				}
+			for (const key of sortedKeys) {
+				const entry = result[key];
+				if (!entry) continue;
+				const { value, secret, scope } = entry;
+				const displayValue = shouldMask && secret ? tui.maskSecret(value) : value;
+				const typeIndicator = secret ? ' [secret]' : '';
+				const scopeIndicator = !useOrgScope ? ` [${scope}]` : '';
+				console.log(
+					`${tui.bold(key)}=${displayValue}${tui.muted(typeIndicator + scopeIndicator)}`
+				);
+			}
 			}
 		}
 

package/src/cmd/cloud/env/push.ts

@@ -80,11 +80,14 @@ export const pushSubcommand = createSubcommand({
 			tui.warning(
 				`Moving public variables to env: ${publicSecretKeys.join(', ')} (these are exposed to the frontend)`
 			);
-			for (const key of publicSecretKeys) {
-				delete secrets[key];
-				env[key] = filteredEnv[key];
+		for (const key of publicSecretKeys) {
+			delete secrets[key];
+			const value = filteredEnv[key];
+			if (value !== undefined) {
+				env[key] = value;
 			}
 		}
+		}
 
 		if (useOrgScope) {
 			// Organization scope

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

@@ -45,9 +45,9 @@ const selectCommand = createSubcommand({
 				);
 			}
 
-			if (regions.length === 1) {
-				selectedRegion = regions[0].region;
-			} else {
+		if (regions.length === 1 && regions[0]) {
+			selectedRegion = regions[0].region;
+		} else {
 				const response = await tui.createPrompt().select<string>({
 					message: 'Select a default region',
 					options: regions.map((r) => ({