@agentuity/cli 0.1.43 → 0.1.45

package/src/cli.ts

@@ -1198,9 +1198,12 @@ async function registerSubcommand(
 						// Recreate apiClient with auth credentials
 						ctx.apiClient = createAPIClient(baseCtx, ctx.config as Config | null);
 					}
+					// Auto-select org when --confirm flag is used
+					const autoSelectOrg = options.confirm === true;
 					if (normalized.requiresOrg) {
 						ctx.orgId = await requireOrg(
-							ctx as CommandContext & { apiClient: APIClientType }
+							ctx as CommandContext & { apiClient: APIClientType },
+							autoSelectOrg
 						);
 					}
 					// Skip org handling if --no-register is set (org only needed for registration)
@@ -1212,7 +1215,8 @@ async function registerSubcommand(
 
 					if (normalized.optionalOrg && ctx.auth && !skipOrg) {
 						ctx.orgId = await selectOptionalOrg(
-							ctx as CommandContext & { apiClient: APIClientType }
+							ctx as CommandContext & { apiClient: APIClientType },
+							autoSelectOrg
 						);
 					}
 					// Skip region handling if --no-register is set (region only needed for registration)
@@ -1302,8 +1306,13 @@ async function registerSubcommand(
 					// Recreate apiClient with auth credentials
 					ctx.apiClient = createAPIClient(baseCtx, ctx.config as Config | null);
 				}
+				// Auto-select org when --confirm flag is used
+				const autoSelectOrg2 = options.confirm === true;
 				if (normalized.requiresOrg) {
-					ctx.orgId = await requireOrg(ctx as CommandContext & { apiClient: APIClientType });
+					ctx.orgId = await requireOrg(
+						ctx as CommandContext & { apiClient: APIClientType },
+						autoSelectOrg2
+					);
 				}
 				// Skip org handling if --no-register is set (org only needed for registration)
 				const skipOrg =
@@ -1314,7 +1323,8 @@ async function registerSubcommand(
 
 				if (normalized.optionalOrg && ctx.auth && !skipOrg) {
 					ctx.orgId = await selectOptionalOrg(
-						ctx as CommandContext & { apiClient: APIClientType }
+						ctx as CommandContext & { apiClient: APIClientType },
+						autoSelectOrg2
 					);
 				}
 				// Skip region handling if --no-register is set (region only needed for registration)
@@ -1454,9 +1464,12 @@ async function registerSubcommand(
 						!!ctx.apiClient,
 						!!auth
 					);
+					// Auto-select org when --confirm flag is used
+					const autoSelectOrg3 = options.confirm === true;
 					if (normalized.requiresOrg && ctx.apiClient) {
 						ctx.orgId = await requireOrg(
-							ctx as CommandContext & { apiClient: APIClientType }
+							ctx as CommandContext & { apiClient: APIClientType },
+							autoSelectOrg3
 						);
 					}
 					// Skip org handling if --no-register is set (org only needed for registration)
@@ -1468,7 +1481,8 @@ async function registerSubcommand(
 
 					if (normalized.optionalOrg && ctx.apiClient && auth && !skipOrg) {
 						ctx.orgId = await selectOptionalOrg(
-							ctx as CommandContext & { apiClient?: APIClientType; auth?: AuthData }
+							ctx as CommandContext & { apiClient?: APIClientType; auth?: AuthData },
+							autoSelectOrg3
 						);
 						baseCtx.logger.trace('selected orgId: %s', ctx.orgId);
 					}
@@ -1551,8 +1565,13 @@ async function registerSubcommand(
 					// Recreate apiClient with auth credentials if auth was provided
 					ctx.apiClient = createAPIClient(baseCtx, ctx.config as Config | null);
 				}
+				// Auto-select org when --confirm flag is used
+				const autoSelectOrg4 = options.confirm === true;
 				if (normalized.requiresOrg && ctx.apiClient) {
-					ctx.orgId = await requireOrg(ctx as CommandContext & { apiClient: APIClientType });
+					ctx.orgId = await requireOrg(
+						ctx as CommandContext & { apiClient: APIClientType },
+						autoSelectOrg4
+					);
 				}
 				// Skip org handling if --no-register is set (org only needed for registration)
 				// For non-schema commands, check options directly (Commander passes all options)
@@ -1563,7 +1582,8 @@ async function registerSubcommand(
 
 				if (normalized.optionalOrg && ctx.apiClient && !skipOrg) {
 					ctx.orgId = await selectOptionalOrg(
-						ctx as CommandContext & { apiClient?: APIClientType; auth?: AuthData }
+						ctx as CommandContext & { apiClient?: APIClientType; auth?: AuthData },
+						autoSelectOrg4
 					);
 				}
 				// Skip region handling if --no-register is set (region only needed for registration)
@@ -1656,14 +1676,18 @@ async function registerSubcommand(
 					if (normalized.requiresAPIClient && !ctx.apiClient) {
 						ctx.apiClient = createAPIClient(baseCtx, ctx.config as Config | null);
 					}
+					// Auto-select org when --confirm flag is used
+					const autoSelectOrg5 = options.confirm === true;
 					if (normalized.requiresOrg && ctx.apiClient) {
 						ctx.orgId = await requireOrg(
-							ctx as CommandContext & { apiClient: APIClientType }
+							ctx as CommandContext & { apiClient: APIClientType },
+							autoSelectOrg5
 						);
 					}
 					if (normalized.optionalOrg && ctx.apiClient && ctx.auth) {
 						ctx.orgId = await requireOrg(
-							ctx as CommandContext & { apiClient: APIClientType }
+							ctx as CommandContext & { apiClient: APIClientType },
+							autoSelectOrg5
 						);
 					}
 					await executeOrValidate(
@@ -1697,11 +1721,19 @@ async function registerSubcommand(
 				if (normalized.requiresAPIClient && !ctx.apiClient) {
 					ctx.apiClient = createAPIClient(baseCtx, ctx.config as Config | null);
 				}
+				// Auto-select org when --confirm flag is used
+				const autoSelectOrg6 = options.confirm === true;
 				if (normalized.requiresOrg && ctx.apiClient) {
-					ctx.orgId = await requireOrg(ctx as CommandContext & { apiClient: APIClientType });
+					ctx.orgId = await requireOrg(
+						ctx as CommandContext & { apiClient: APIClientType },
+						autoSelectOrg6
+					);
 				}
 				if (normalized.optionalOrg && ctx.apiClient && ctx.auth) {
-					ctx.orgId = await requireOrg(ctx as CommandContext & { apiClient: APIClientType });
+					ctx.orgId = await requireOrg(
+						ctx as CommandContext & { apiClient: APIClientType },
+						autoSelectOrg6
+					);
 				}
 				if ((normalized.requiresRegion || normalized.optionalRegion) && ctx.apiClient) {
 					const apiClient: APIClientType = ctx.apiClient as APIClientType;

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

@@ -154,10 +154,11 @@ if (hasWorkbench) {
 if (isDevelopment() && process.env.VITE_PORT) {
 	const VITE_ASSET_PORT = parseInt(process.env.VITE_PORT, 10);
 
-	const proxyToVite = async (c: Context) => {
-		const viteUrl = \`http://127.0.0.1:\${VITE_ASSET_PORT}\${c.req.path}\`;
+	const proxyToVite = async (c: Context, pathOverride?: string) => {
+		const targetPath = pathOverride ?? c.req.path;
+		const viteUrl = \`http://127.0.0.1:\${VITE_ASSET_PORT}\${targetPath}\`;
 		try {
-			otel.logger.debug(\`[Proxy] \${c.req.method} \${c.req.path} -> Vite:\${VITE_ASSET_PORT}\`);
+			otel.logger.debug(\`[Proxy] \${c.req.method} \${c.req.path} -> Vite:\${VITE_ASSET_PORT}\${targetPath}\`);
 			const res = await fetch(viteUrl, { signal: AbortSignal.timeout(10000) });
 			otel.logger.debug(\`[Proxy] \${c.req.path} -> \${res.status} (\${res.headers.get('content-type')})\`);
 			return new Response(res.body, {
@@ -276,34 +277,42 @@ if (isDevelopment() && process.env.VITE_PORT) {
 	});
 
 	// Vite client scripts and HMR
-	app.get('/@vite/*', proxyToVite);
-	app.get('/@react-refresh', proxyToVite);
+	app.get('/@vite/*', (c: Context) => proxyToVite(c));
+	app.get('/@react-refresh', (c: Context) => proxyToVite(c));
 
 	// Source files for HMR
-	app.get('/src/web/*', proxyToVite);
-	app.get('/src/*', proxyToVite); // Catch-all for other source files
+	app.get('/src/web/*', (c: Context) => proxyToVite(c));
+	app.get('/src/*', (c: Context) => proxyToVite(c)); // Catch-all for other source files
 
 	// Workbench source files (in .agentuity/workbench-src/)
-	app.get('/.agentuity/workbench-src/*', proxyToVite);
+	app.get('/.agentuity/workbench-src/*', (c: Context) => proxyToVite(c));
 
 	// Node modules (Vite transforms these)
-	app.get('/node_modules/*', proxyToVite);
+	app.get('/node_modules/*', (c: Context) => proxyToVite(c));
 
 	// Scoped packages (e.g., @agentuity/*, @types/*)
-	app.get('/@*', proxyToVite);
+	app.get('/@*', (c: Context) => proxyToVite(c));
 
 	// File system access (for Vite's @fs protocol)
-	app.get('/@fs/*', proxyToVite);
+	app.get('/@fs/*', (c: Context) => proxyToVite(c));
 
 	// Module resolution (for Vite's @id protocol)
-	app.get('/@id/*', proxyToVite);
+	app.get('/@id/*', (c: Context) => proxyToVite(c));
+
+	// Static assets - Vite serves src/web/public/* at root, but code uses /public/* paths
+	// In production, the plugin transforms /public/foo.svg to CDN URLs
+	// Rewrite /public/foo.svg -> /foo.svg before proxying to Vite
+	app.get('/public/*', (c: Context) => {
+		const rootPath = c.req.path.replace(/^\\/public/, '');
+		return proxyToVite(c, rootPath);
+	});
 
 	// Any .js, .jsx, .ts, .tsx files (catch remaining modules)
-	app.get('/*.js', proxyToVite);
-	app.get('/*.jsx', proxyToVite);
-	app.get('/*.ts', proxyToVite);
-	app.get('/*.tsx', proxyToVite);
-	app.get('/*.css', proxyToVite);
+	app.get('/*.js', (c: Context) => proxyToVite(c));
+	app.get('/*.jsx', (c: Context) => proxyToVite(c));
+	app.get('/*.ts', (c: Context) => proxyToVite(c));
+	app.get('/*.tsx', (c: Context) => proxyToVite(c));
+	app.get('/*.css', (c: Context) => proxyToVite(c));
 }
 `;
 

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

@@ -1,20 +1,21 @@
 /**
  * Vite plugin to fix incorrect public asset paths
  *
- * Developers sometimes accidentally use source paths or relative paths instead
- * of the correct absolute root path. This plugin:
+ * Developers should use /public/ paths for static assets from src/web/public/.
+ * In production, these paths are transformed to CDN URLs.
  *
- * 1. During build: Rewrites all public asset paths to root paths (/)
- * 2. During dev: Warns about incorrect paths so developers can fix them
+ * This plugin:
+ * 1. During build: Rewrites /public/* paths to CDN URLs
+ * 2. During dev: Warns only about incorrect source paths (src/web/public/)
  *
- * Patterns handled (all rewritten to root path in production):
- * - '/src/web/public/foo.svg'  → '/foo.svg'
- * - './src/web/public/foo.svg' → '/foo.svg'
- * - 'src/web/public/foo.svg'   → '/foo.svg'
- * - './public/foo.svg'         → '/foo.svg'
- * - '/public/foo.svg'          → '/foo.svg'
+ * Supported patterns (work in dev, rewritten to CDN in production):
+ * - '/public/foo.svg'   → CDN URL (recommended)
+ * - './public/foo.svg'  → CDN URL
  *
- * Vite's base config then rewrites these to CDN URLs (e.g., https://cdn.example.com/deploy/client/foo.svg)
+ * Incorrect patterns (warned in dev, rewritten in production):
+ * - '/src/web/public/foo.svg'  → CDN URL
+ * - './src/web/public/foo.svg' → CDN URL
+ * - 'src/web/public/foo.svg'   → CDN URL
  */
 
 import type { Plugin } from 'vite';
@@ -29,23 +30,41 @@ export interface PublicAssetPathPluginOptions {
 interface PathPattern {
 	regex: RegExp;
 	description: string;
+	/** Replacement template - use {base} for the target base URL */
+	replacement: string;
 }
 
 /**
- * Create fresh regex instances for each transform call
- * (RegExp with global flag maintains state via lastIndex)
+ * Patterns that are incorrect - reference source paths directly
  */
-function createPatterns(): PathPattern[] {
+function createIncorrectPatterns(): PathPattern[] {
 	return [
 		// '/src/web/public/...' or './src/web/public/...' or 'src/web/public/...'
 		{
 			regex: /(['"`])(?:\.?\/)?src\/web\/public\//g,
 			description: 'src/web/public/',
+			replacement: '$1{base}',
 		},
-		// './public/...' (relative public path - should be absolute)
+	];
+}
+
+/**
+ * Patterns that need rewriting for production CDN
+ * Both patterns simply replace the prefix while preserving the rest of the path naturally.
+ */
+function createPublicPatterns(): PathPattern[] {
+	return [
+		// './public/...' (relative public path) - replace prefix, keep rest
 		{
 			regex: /(['"`])\.\/public\//g,
 			description: './public/',
+			replacement: '$1{base}',
+		},
+		// '/public/...' (absolute public path) - replace prefix, keep rest
+		{
+			regex: /(['"`])\/public\//g,
+			description: '/public/',
+			replacement: '$1{base}',
 		},
 	];
 }
@@ -53,21 +72,17 @@ function createPatterns(): PathPattern[] {
 /**
  * Vite plugin that fixes public asset paths and rewrites to CDN URLs
  *
- * Rewrites all public asset paths to CDN URLs in production, or root paths
- * if no CDN base URL is provided.
+ * Rewrites all public asset paths to CDN URLs in production.
  *
  * @example
  * // In vite config:
  * plugins: [publicAssetPathPlugin({ cdnBaseUrl: 'https://cdn.example.com/deploy/client/' })]
  *
- * // Transforms in production with CDN:
- * // '/src/web/public/logo.svg'  → 'https://cdn.example.com/deploy/client/logo.svg'
- * // './src/web/public/logo.svg' → 'https://cdn.example.com/deploy/client/logo.svg'
- * // '/public/logo.svg'          → 'https://cdn.example.com/deploy/client/logo.svg'
+ * // In code, use /public/ paths:
+ * <img src="/public/logo.svg" />
  *
- * // Transforms in production without CDN:
- * // '/src/web/public/logo.svg'  → '/logo.svg'
- * // '/public/logo.svg'          → '/logo.svg'
+ * // Transforms in production:
+ * // '/public/logo.svg' → 'https://cdn.example.com/deploy/client/logo.svg'
  */
 export function publicAssetPathPlugin(options: PublicAssetPathPluginOptions = {}): Plugin {
 	const { warnInDev = true, cdnBaseUrl } = options;
@@ -89,17 +104,18 @@ export function publicAssetPathPlugin(options: PublicAssetPathPluginOptions = {}
 			}
 
 			// Quick check: does the code contain any patterns we care about?
-			const hasIncorrectPaths = code.includes('src/web/public/') || code.includes('./public/');
-			const hasPublicPaths = code.includes('/public/');
+			const hasIncorrectSourcePaths = code.includes('src/web/public/');
+			const hasPublicPaths = code.includes('/public/') || code.includes('./public/');
 
-			if (!hasIncorrectPaths && !hasPublicPaths) {
+			if (!hasIncorrectSourcePaths && !hasPublicPaths) {
 				return null;
 			}
 
-			// In dev mode, optionally warn about incorrect paths but don't transform
+			// In dev mode, only warn about incorrect source paths (src/web/public/)
+			// /public/ and ./public/ paths work correctly in dev mode
 			if (isDev) {
-				if (warnInDev && hasIncorrectPaths) {
-					const patterns = createPatterns();
+				if (warnInDev && hasIncorrectSourcePaths) {
+					const patterns = createIncorrectPatterns();
 					const foundPatterns: string[] = [];
 
 					for (const { regex, description } of patterns) {
@@ -121,37 +137,43 @@ export function publicAssetPathPlugin(options: PublicAssetPathPluginOptions = {}
 							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.`
+									`\nUse '/public/...' paths for static assets.`
 							);
 						}
 					}
 				}
 				// In dev mode, never transform - Vite serves from source paths
+				// and the Bun server proxies /public/* to Vite
 				return null;
 			}
 
-		// Build mode: transform paths
-		let transformed = code;
-
-		// Determine target URL: CDN base if provided, otherwise root
-		const targetBase = cdnBaseUrl ? (cdnBaseUrl.endsWith('/') ? cdnBaseUrl : `${cdnBaseUrl}/`) : '/';
+			// Build mode: transform paths to CDN URLs
+			let transformed = code;
+
+			// Determine target URL: CDN base if provided, otherwise root
+			const targetBase = cdnBaseUrl
+				? cdnBaseUrl.endsWith('/')
+					? cdnBaseUrl
+					: `${cdnBaseUrl}/`
+				: '/';
+
+			// Transform incorrect source paths (src/web/public/) → CDN
+			if (hasIncorrectSourcePaths) {
+				const patterns = createIncorrectPatterns();
+				for (const { regex, replacement } of patterns) {
+					const replaceRegex = new RegExp(regex.source, regex.flags);
+					transformed = transformed.replace(replaceRegex, replacement.replace('{base}', targetBase));
+				}
+			}
 
-		// First, fix incorrect source paths (src/web/public/, ./public/) → targetBase
-		if (hasIncorrectPaths) {
-			const patterns = createPatterns();
-			for (const { regex } of patterns) {
-				const replaceRegex = new RegExp(regex.source, regex.flags);
-				transformed = transformed.replace(replaceRegex, `$1${targetBase}`);
+			// Transform public paths → CDN
+			if (hasPublicPaths) {
+				const publicPatterns = createPublicPatterns();
+				for (const { regex, replacement } of publicPatterns) {
+					const replaceRegex = new RegExp(regex.source, regex.flags);
+					transformed = transformed.replace(replaceRegex, replacement.replace('{base}', targetBase));
+				}
 			}
-		}
-
-		// Then, rewrite /public/foo → {targetBase}foo
-		if (hasPublicPaths) {
-			// Match '/public/...' paths in strings (single, double, or backtick quotes)
-			// Captures: $1 = quote char, $2 = path after /public/
-			const publicPathRegex = /(['"`])\/public\/([^'"`\s]+)/g;
-			transformed = transformed.replace(publicPathRegex, `$1${targetBase}$2`);
-		}
 
 			// Return transformed code if changed
 			if (transformed !== code) {

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

@@ -68,7 +68,9 @@ export async function generateAssetServerConfig(
 		root: rootDir,
 		base: '/',
 		clearScreen: false,
-		publicDir: false, // Don't serve public dir - Bun server handles that
+		// Serve public assets from src/web/public/ at root path (e.g., /favicon.png)
+		// The Bun server proxies /public/* requests to Vite, rewriting to root paths
+		publicDir: join(rootDir, 'src', 'web', 'public'),
 
 		resolve: {
 			alias,

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

@@ -153,7 +153,7 @@ export async function runViteBuild(options: ViteBuildOptions): Promise<void> {
 		// Use CDN for all non-dev builds with a deploymentId (including local region)
 		const isLocalRegion = options.region === 'local';
 		const cdnDomain = isLocalRegion
-			? 'localstack-static-assets.t3.storage.dev'
+			? 'localstack-static-assets.t3.storageapi.dev'
 			: 'cdn.agentuity.com';
 		const cdnBaseUrl =
 			!dev && deploymentId ? `https://${cdnDomain}/${deploymentId}/client/` : undefined;

package/src/cmd/canary/index.ts

@@ -3,7 +3,7 @@ import { z } from 'zod';
 import { $ } from 'bun';
 import * as tui from '../../tui';
 
-const CANARY_BASE_URL = 'https://agentuity-sdk-objects.t3.storage.dev/npm';
+const CANARY_BASE_URL = 'https://agentuity-sdk-objects.t3.storageapi.dev/npm';
 
 const CanaryArgsSchema = z.object({
 	args: z

package/src/cmd/cloud/env/org-util.ts

@@ -9,12 +9,14 @@ import { listOrganizations } from '@agentuity/server';
  * @param apiClient - The API client
  * @param config - The CLI config (may be null)
  * @param orgOption - The --org option value (true for default/prompt, or explicit org ID)
+ * @param autoSelect - If true, auto-select preferred org without prompting (for --confirm)
  * @returns The resolved organization ID
  */
 export async function resolveOrgId(
 	apiClient: APIClient,
 	config: Config | null,
-	orgOption: boolean | string
+	orgOption: boolean | string,
+	autoSelect?: boolean
 ): Promise<string> {
 	// If an explicit org ID was provided (string), use it directly
 	if (typeof orgOption === 'string' && orgOption !== 'true') {
@@ -25,8 +27,9 @@ export async function resolveOrgId(
 	const orgs = await tui.spinner('Fetching organizations', () => listOrganizations(apiClient));
 
 	// Use preference if available, otherwise prompt
+	// Pass autoSelect to skip prompting when --confirm is used
 	const preferredOrgId = config?.preferences?.orgId;
-	return tui.selectOrganization(orgs, preferredOrgId);
+	return tui.selectOrganization(orgs, preferredOrgId, autoSelect);
 }
 
 /**