@agentuity/cli 0.1.42 → 0.1.44

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,
@@ -99,12 +101,13 @@ export async function generateAssetServerConfig(
 				credentials: true,
 			},
 
-			// HMR configuration - client must connect to Vite asset server directly
-			// Do NOT set port/clientPort - let Vite use the actual server port it binds to
-			// (important when strictPort: false and Vite falls back to an alternate port)
+			// HMR configuration for development with tunnel support (*.agentuity.live)
+			// Do NOT set host/protocol - let Vite auto-detect from page origin
+			// This allows HMR to work both locally and through the Gravity tunnel
+			// The Bun server proxies /__vite_hmr WebSocket connections to Vite
 			hmr: {
-				protocol: 'ws',
-				host: '127.0.0.1',
+				// Use a dedicated path for HMR WebSocket to enable proxying
+				path: '/__vite_hmr',
 			},
 
 			// Don't open browser - Bun server will be the entry point

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

@@ -119,7 +119,9 @@ export async function startViteAssetServer(
 		);
 	}
 	logger.debug(`Asset server will handle: HMR, React transformation, source maps`);
-	logger.debug(`HMR WebSocket configured to connect to ws://127.0.0.1:${actualPort}`);
+	logger.debug(
+		`HMR WebSocket configured at /__vite_hmr (proxied through Bun server for tunnel support)`
+	);
 
 	return { server, port: actualPort };
 }

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

@@ -149,13 +149,22 @@ export async function runViteBuild(options: ViteBuildOptions): Promise<void> {
 			analyticsEnabled = false,
 		} = options;
 
+		// Determine CDN base URL for production builds
+		// 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'
+			: 'cdn.agentuity.com';
+		const cdnBaseUrl =
+			!dev && deploymentId ? `https://${cdnDomain}/${deploymentId}/client/` : undefined;
+
 		// Load custom user plugins from agentuity.config.ts if it exists
 		const clientOutDir = join(rootDir, '.agentuity/client');
 		const plugins = [
 			react(),
 			browserEnvPlugin(),
-			// Fix incorrect public asset paths (e.g., '/src/web/public/...' → '/public/...')
-			publicAssetPathPlugin(),
+			// Fix incorrect public asset paths and rewrite to CDN URLs
+			publicAssetPathPlugin({ cdnBaseUrl }),
 			flattenHtmlOutputPlugin(clientOutDir),
 			// Emit analytics beacon as hashed CDN asset (prod builds only)
 			beaconPlugin({ enabled: analyticsEnabled && !dev }),
@@ -177,15 +186,6 @@ export async function runViteBuild(options: ViteBuildOptions): Promise<void> {
 			);
 		}
 
-		// Determine CDN base URL for production builds
-		// 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'
-			: 'cdn.agentuity.com';
-		const cdnBaseUrl =
-			!dev && deploymentId ? `https://${cdnDomain}/${deploymentId}/client/` : undefined;
-
 		viteConfig = {
 			// Use project root as Vite root so plugins (e.g., TanStack Router) resolve paths
 			// from the repo root, matching where agentuity.config.ts is located
@@ -203,16 +203,17 @@ export async function runViteBuild(options: ViteBuildOptions): Promise<void> {
 					? JSON.stringify(workbenchRoute)
 					: 'undefined',
 			},
-			build: {
-				outDir: clientOutDir,
-				rollupOptions: {
-					input: htmlPath,
-				},
-				manifest: true,
-				emptyOutDir: true,
-				// Disable copying public files - Vite already includes them in assets with hashing
-				copyPublicDir: false,
+		build: {
+			outDir: clientOutDir,
+			rollupOptions: {
+				input: htmlPath,
 			},
+			manifest: true,
+			emptyOutDir: true,
+			// Copy public files to output for CDN upload (production builds only)
+			// In dev mode, Vite serves them directly from src/web/public/
+			copyPublicDir: !dev,
+		},
 			logLevel: 'warn',
 		};
 	} else if (mode === 'workbench') {

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);
 }
 
 /**

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

@@ -0,0 +1,248 @@
+import { z } from 'zod';
+import { basename } from 'path';
+import { createCommand } from '../../../types';
+import * as tui from '../../../tui';
+import { createStorageAdapter } from './util';
+import { getCommand } from '../../../command-prefix';
+
+const StreamCreateResponseSchema = z.object({
+	id: z.string().describe('Stream ID'),
+	namespace: z.string().describe('Stream namespace'),
+	url: z.string().describe('Public URL'),
+	sizeBytes: z.number().describe('Size in bytes'),
+	metadata: z.record(z.string(), z.string()).describe('Stream metadata'),
+	expiresAt: z.string().optional().describe('Expiration timestamp'),
+});
+
+export const createSubcommand = createCommand({
+	name: 'create',
+	aliases: ['new'],
+	description: 'Create a new stream and upload content',
+	tags: ['mutating', 'creates-resource', 'slow', 'requires-auth', 'uses-stdin'],
+	requires: { auth: true, region: true },
+	optional: { project: true },
+	idempotent: false,
+	examples: [
+		{
+			command: getCommand('cloud stream create memory-share ./notes.md'),
+			description: 'Create stream from file',
+		},
+		{
+			command: getCommand(
+				'cloud stream create memory-share ./data.json --content-type application/json'
+			),
+			description: 'Create stream with explicit content type',
+		},
+		{
+			command: `cat summary.md | ${getCommand('cloud stream create memory-share -')}`,
+			description: 'Create stream from stdin',
+		},
+		{
+			command: getCommand('cloud stream create memory-share ./notes.md --ttl 3600'),
+			description: 'Create stream with 1 hour TTL',
+		},
+		{
+			command: getCommand(
+				'cloud stream create memory-share ./notes.md --metadata type=summary,source=session'
+			),
+			description: 'Create stream with metadata',
+		},
+		{
+			command: getCommand('cloud stream create memory-share ./large.json --compress'),
+			description: 'Create compressed stream',
+		},
+	],
+	schema: {
+		args: z.object({
+			namespace: z.string().min(1).max(254).describe('Stream namespace (1-254 characters)'),
+			filename: z.string().describe('File path to upload or "-" for STDIN'),
+		}),
+		options: z.object({
+			metadata: z
+				.string()
+				.optional()
+				.describe('Metadata key=value pairs (comma-separated: key1=value1,key2=value2)'),
+			contentType: z
+				.string()
+				.optional()
+				.describe('Content type (auto-detected from extension if not provided)'),
+			compress: z.boolean().optional().describe('Enable gzip compression'),
+			ttl: z.coerce
+				.number()
+				.optional()
+				.describe('TTL in seconds (60-7776000, or 0/null for never expires)'),
+		}),
+		response: StreamCreateResponseSchema,
+	},
+	webUrl: '/services/stream',
+
+	async handler(ctx) {
+		const { args, opts, options } = ctx;
+		const started = Date.now();
+		const storage = await createStorageAdapter(ctx);
+
+		// Parse metadata if provided
+		let metadata: Record<string, string> | undefined;
+		if (opts.metadata) {
+			const validPairs: Record<string, string> = {};
+			const malformed: string[] = [];
+			const pairs = opts.metadata.split(',');
+
+			for (const pair of pairs) {
+				const trimmedPair = pair.trim();
+				if (!trimmedPair) continue;
+
+				const firstEqualIdx = trimmedPair.indexOf('=');
+				if (firstEqualIdx === -1) {
+					malformed.push(trimmedPair);
+					continue;
+				}
+
+				const key = trimmedPair.substring(0, firstEqualIdx).trim();
+				const value = trimmedPair.substring(firstEqualIdx + 1).trim();
+
+				if (!key || !value) {
+					malformed.push(trimmedPair);
+					continue;
+				}
+
+				validPairs[key] = value;
+			}
+
+			if (malformed.length > 0) {
+				ctx.logger.warn(`Skipping malformed metadata pairs: ${malformed.join(', ')}`);
+			}
+
+			if (Object.keys(validPairs).length > 0) {
+				metadata = validPairs;
+			}
+		}
+
+		// Determine content type
+		let contentType = opts.contentType;
+		if (!contentType) {
+			// Auto-detect from filename extension
+			const filename = args.filename === '-' ? 'stdin' : args.filename;
+			const dotIndex = filename.lastIndexOf('.');
+			const ext = dotIndex > 0 ? filename.substring(dotIndex + 1).toLowerCase() : undefined;
+			// Text-based types should include charset=utf-8 for proper browser rendering
+			const mimeTypes: Record<string, string> = {
+				txt: 'text/plain; charset=utf-8',
+				md: 'text/markdown; charset=utf-8',
+				html: 'text/html; charset=utf-8',
+				css: 'text/css; charset=utf-8',
+				yaml: 'application/x-yaml; charset=utf-8',
+				yml: 'application/x-yaml; charset=utf-8',
+				js: 'application/javascript; charset=utf-8',
+				ts: 'application/typescript; charset=utf-8',
+				json: 'application/json; charset=utf-8',
+				xml: 'application/xml; charset=utf-8',
+				pdf: 'application/pdf',
+				zip: 'application/zip',
+				jpg: 'image/jpeg',
+				jpeg: 'image/jpeg',
+				png: 'image/png',
+				gif: 'image/gif',
+				svg: 'image/svg+xml; charset=utf-8',
+				mp4: 'video/mp4',
+				mp3: 'audio/mpeg',
+			};
+			contentType = ext ? mimeTypes[ext] : 'application/octet-stream';
+		}
+
+		// Create the stream
+		const stream = await storage.create(args.namespace, {
+			metadata,
+			contentType,
+			compress: opts.compress ? true : undefined,
+			ttl: opts.ttl,
+		});
+
+		// Read and write content
+		let inputStream: ReadableStream<Uint8Array>;
+
+		if (args.filename === '-') {
+			// Stream from STDIN
+			inputStream = Bun.stdin.stream();
+		} else {
+			// Stream from file
+			const file = Bun.file(args.filename);
+			if (!(await file.exists())) {
+				tui.fatal(`File not found: ${args.filename}`);
+			}
+			inputStream = file.stream();
+		}
+
+		// Write content to stream in chunks
+		const reader = inputStream.getReader();
+		const MAX_CHUNK_SIZE = 5 * 1024 * 1024; // 5MB max per write
+
+		try {
+			while (true) {
+				const { done, value } = await reader.read();
+				if (done) break;
+
+				// If chunk is larger than 5MB, split it
+				if (value.length > MAX_CHUNK_SIZE) {
+					let offset = 0;
+					while (offset < value.length) {
+						const chunk = value.slice(offset, offset + MAX_CHUNK_SIZE);
+						await stream.write(chunk);
+						offset += MAX_CHUNK_SIZE;
+					}
+				} else {
+					await stream.write(value);
+				}
+			}
+		} finally {
+			reader.releaseLock();
+		}
+
+		// Close the stream
+		await stream.close();
+
+		const durationMs = Date.now() - started;
+		const sizeBytes = stream.bytesWritten;
+
+		// Get stream info to retrieve expiresAt
+		let expiresAt: string | undefined;
+		try {
+			const info = await storage.get(stream.id);
+			expiresAt = info.expiresAt;
+		} catch {
+			// expiresAt is optional, ignore errors
+		}
+
+		if (!options.json) {
+			const sourceLabel = args.filename === '-' ? 'stdin' : basename(args.filename);
+			console.log(`Namespace: ${tui.bold(args.namespace)}`);
+			console.log(`ID:        ${stream.id}`);
+			console.log(`Size:      ${tui.formatBytes(sizeBytes)}`);
+			console.log(`URL:       ${tui.link(stream.url)}`);
+			if (expiresAt) {
+				console.log(`Expires:   ${expiresAt}`);
+			}
+			if (metadata && Object.keys(metadata).length > 0) {
+				console.log(`Metadata:`);
+				for (const [key, value] of Object.entries(metadata)) {
+					console.log(`  ${key}: ${value}`);
+				}
+			}
+			if (opts.compress) {
+				console.log(`Compressed: yes`);
+			}
+			tui.success(`created stream from ${sourceLabel} in ${durationMs.toFixed(1)}ms`);
+		}
+
+		return {
+			id: stream.id,
+			namespace: args.namespace,
+			url: stream.url,
+			sizeBytes,
+			metadata: metadata ?? {},
+			expiresAt,
+		};
+	},
+});
+
+export default createSubcommand;

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

@@ -13,7 +13,8 @@ export const deleteSubcommand = createCommand({
 	description: 'Delete a stream by ID (soft delete)',
 	tags: ['destructive', 'deletes-resource', 'slow', 'requires-auth'],
 	idempotent: true,
-	requires: { auth: true, project: true },
+	requires: { auth: true, region: true },
+	optional: { project: true },
 	examples: [
 		{ command: getCommand('stream delete stream-id-123'), description: 'Delete a stream' },
 		{

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

@@ -16,7 +16,8 @@ export const getSubcommand = createCommand({
 	name: 'get',
 	description: 'Get detailed information about a specific stream',
 	tags: ['read-only', 'slow', 'requires-auth'],
-	requires: { auth: true, project: true },
+	requires: { auth: true, region: true },
+	optional: { project: true },
 	idempotent: true,
 	examples: [
 		{ command: getCommand('stream get stream-id-123'), description: 'Get stream details' },

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

@@ -1,4 +1,5 @@
 import { createCommand } from '../../../types';
+import createSubcommand from './create';
 import listSubcommand from './list';
 import getSubcommand from './get';
 import deleteSubcommand from './delete';
@@ -10,10 +11,18 @@ export const streamCommand = createCommand({
 	description: 'Manage durable streams',
 	tags: ['slow', 'requires-auth'],
 	examples: [
+		{
+			command: getCommand('cloud stream create memory-share ./notes.md'),
+			description: 'Create stream from file',
+		},
+		{
+			command: `cat data.json | ${getCommand('cloud stream create memory-share -')}`,
+			description: 'Create stream from stdin',
+		},
 		{ command: getCommand('cloud stream list'), description: 'List all streams' },
 		{ command: getCommand('cloud stream get <id>'), description: 'Get stream details' },
 	],
-	subcommands: [listSubcommand, getSubcommand, deleteSubcommand],
+	subcommands: [createSubcommand, listSubcommand, getSubcommand, deleteSubcommand],
 });
 
 export default streamCommand;

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

@@ -22,7 +22,8 @@ export const listSubcommand = createCommand({
 	aliases: ['ls'],
 	description: 'List recent streams with optional filtering',
 	tags: ['read-only', 'slow', 'requires-auth'],
-	requires: { auth: true, project: true },
+	requires: { auth: true, region: true },
+	optional: { project: true },
 	idempotent: true,
 	examples: [
 		{ command: getCommand('cloud stream list'), description: 'List all streams' },

package/src/cmd/cloud/stream/util.ts

@@ -1,35 +1,62 @@
-import { StreamStorageService, Logger } from '@agentuity/core';
+import { StreamStorageService, type Logger } from '@agentuity/core';
 import { createServerFetchAdapter, getServiceUrls } from '@agentuity/server';
 import { loadProjectSDKKey } from '../../../config';
-import { ErrorCode } from '../../../errors';
-import type { Config } from '../../../types';
+import type { AuthData, Config, GlobalOptions, ProjectConfig } from '../../../types';
 import * as tui from '../../../tui';
 
 export async function createStorageAdapter(ctx: {
 	logger: Logger;
 	projectDir: string;
+	auth: AuthData;
+	region: string;
+	project?: ProjectConfig;
 	config: Config | null;
-	project: { region: string };
+	options: GlobalOptions;
 }) {
+	// Try to get SDK key from project context first (preferred for project-based auth)
 	const sdkKey = await loadProjectSDKKey(ctx.logger, ctx.projectDir);
-	if (!sdkKey) {
-		tui.fatal(
-			`Couldn't find the AGENTUITY_SDK_KEY in ${ctx.projectDir} .env file`,
-			ErrorCode.CONFIG_NOT_FOUND
-		);
+
+	let authToken: string;
+	let queryParams: Record<string, string> | undefined;
+
+	if (sdkKey) {
+		// Use SDK key auth (project context available)
+		authToken = sdkKey;
+		ctx.logger.trace('using SDK key auth for stream');
+	} else {
+		// Use CLI key auth with orgId query param
+		// Pulse server expects orgId as query param for CLI tokens (ck_*)
+		// IMPORTANT: For CLI key auth, prefer user's org ID over project's org ID
+		// because the CLI key is validated against the user's orgs, not the project's org
+		const orgId =
+			ctx.options.orgId ??
+			process.env.AGENTUITY_CLOUD_ORG_ID ??
+			ctx.config?.preferences?.orgId ??
+			ctx.project?.orgId;
+
+		if (!orgId) {
+			tui.fatal(
+				'Organization ID is required. Either run from a project directory, use --org-id flag, or set AGENTUITY_CLOUD_ORG_ID environment variable.'
+			);
+		}
+
+		authToken = ctx.auth.apiKey;
+		queryParams = { orgId };
+		ctx.logger.trace('using CLI key auth with orgId query param for stream');
 	}
 
+	const baseUrl = getServiceUrls(ctx.region).stream;
+
 	const adapter = createServerFetchAdapter(
 		{
 			headers: {
-				Authorization: `Bearer ${sdkKey}`,
+				Authorization: `Bearer ${authToken}`,
 			},
+			queryParams,
 		},
 		ctx.logger
 	);
 
-	const baseUrl = getServiceUrls(ctx.project.region).stream;
-
 	ctx.logger.trace('using stream url: %s', baseUrl);
 
 	return new StreamStorageService(baseUrl, adapter);