@agentuity/cli 3.0.0-alpha.6 → 3.0.0-alpha.7

package/src/cmd/cloud/sandbox/run.ts

@@ -2,7 +2,7 @@ import { z } from 'zod';
 import { Writable } from 'node:stream';
 import { createCommand } from '../../../types';
 import * as tui from '../../../tui';
-import { createSandboxClient, parseFileArgs, cacheSandboxRegion } from './util';
+import { createSandboxClient, parseFileArgs, cacheSandboxRegion, detectNullStream } from './util';
 import { getCommand } from '../../../command-prefix';
 import { sandboxRun } from '@agentuity/server';
 import { validateAptDependencies } from '../../../utils/apt-validator';
@@ -59,6 +59,11 @@ export const runSubcommand = createCommand({
 				.default(false)
 				.optional()
 				.describe('Include timestamps in output (default: true)'),
+			quiet: z
+				.boolean()
+				.default(false)
+				.optional()
+				.describe('Suppress output (do not create stdout/stderr streams)'),
 			snapshot: z.string().optional().describe('Snapshot ID or tag to restore from'),
 			dependency: z
 				.array(z.string())
@@ -149,13 +154,46 @@ export const runSubcommand = createCommand({
 		// Determine if we have stdin data (not a TTY means piped input)
 		const hasStdin = !process.stdin.isTTY;
 
-		// For JSON output, we need to capture output instead of streaming to process
-		const stdout = options.json
-			? createCaptureStream((chunk) => outputChunks.push(chunk))
-			: process.stdout;
-		const stderr = options.json
-			? createCaptureStream((chunk) => outputChunks.push(chunk))
-			: process.stderr;
+		// Detect if stdout/stderr are redirected to /dev/null
+		const stdoutIsNull = detectNullStream(1);
+		const stderrIsNull = detectNullStream(2);
+
+		// Detect stream configuration based on TTY status and flags
+		const streamConfig: {
+			timestamps?: boolean;
+			stdin?: string;
+			stdout?: string;
+			stderr?: string;
+		} = {
+			timestamps: opts.timestamps,
+			// Skip stdin stream when no stdin data available
+			stdin: hasStdin ? undefined : 'ignore',
+		};
+
+		// --quiet: suppress all output streams (no server streams, no local capture)
+		if (opts.quiet) {
+			streamConfig.stdout = 'ignore';
+			streamConfig.stderr = 'ignore';
+		} else if (!options.json) {
+			// Auto-detect /dev/null redirection (only when not in JSON mode)
+			// In JSON mode we need output for the response, so keep streams even if redirected
+			if (stdoutIsNull) {
+				streamConfig.stdout = 'ignore';
+			}
+			if (stderrIsNull) {
+				streamConfig.stderr = 'ignore';
+			}
+		}
+
+		// For JSON output or quiet mode, we need to capture output instead of streaming to process
+		const stdout =
+			options.json || opts.quiet || stdoutIsNull
+				? createCaptureStream((chunk) => outputChunks.push(chunk))
+				: process.stdout;
+		const stderr =
+			options.json || opts.quiet || stderrIsNull
+				? createCaptureStream((chunk) => outputChunks.push(chunk))
+				: process.stderr;
 
 		try {
 			const result = await sandboxRun(client, {
@@ -180,7 +218,7 @@ export const runSubcommand = createCommand({
 					network: opts.network ? { enabled: true } : undefined,
 					timeout: opts.timeout ? { execution: opts.timeout } : undefined,
 					env: Object.keys(envMap).length > 0 ? envMap : undefined,
-					stream: opts.timestamps !== undefined ? { timestamps: opts.timestamps } : undefined,
+					stream: streamConfig,
 					snapshot: opts.snapshot,
 					dependencies: opts.dependency,
 					scopes: opts.scope,

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

@@ -1,4 +1,4 @@
-import { readFileSync } from 'node:fs';
+import { fstatSync, readFileSync, statSync } from 'node:fs';
 import { resolve } from 'node:path';
 import type { FileToWrite, Logger } from '@agentuity/core';
 import { APIClient, getServiceUrls, sandboxGet } from '@agentuity/server';
@@ -8,6 +8,25 @@ import { ErrorCode } from '../../../errors';
 import * as tui from '../../../tui';
 import type { AuthData, Config } from '../../../types';
 
+/**
+ * Detect if a file descriptor is redirected to /dev/null (or NUL on Windows).
+ * Used to optimize stream creation - when output goes to /dev/null, we can
+ * skip creating the stream entirely on the server.
+ *
+ * @param fd - File descriptor (1 for stdout, 2 for stderr)
+ * @returns true if the fd points to /dev/null
+ */
+export function detectNullStream(fd: number): boolean {
+	try {
+		const fdStat = fstatSync(fd);
+		const nullPath = process.platform === 'win32' ? 'NUL' : '/dev/null';
+		const nullStat = statSync(nullPath);
+		return fdStat.dev === nullStat.dev && fdStat.ino === nullStat.ino;
+	} catch {
+		return false;
+	}
+}
+
 export function createSandboxClient(logger: Logger, auth: AuthData, region: string): APIClient {
 	return new APIClient(getServiceUrls(region).catalyst, logger, auth.apiKey);
 }

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

@@ -1,10 +1,4 @@
-import {
-	type AgentInfo,
-	APIError,
-	type EvalRun,
-	type SpanNode,
-	sessionGet,
-} from '@agentuity/server';
+import { type AgentInfo, APIError, type SpanNode, sessionGet } from '@agentuity/server';
 import { z } from 'zod';
 import { getCommand } from '../../../command-prefix';
 import { getGlobalCatalystAPIClient } from '../../../config';
@@ -58,19 +52,6 @@ const SessionGetResponseSchema = z.object({
 			})
 		)
 		.describe('Agents'),
-	eval_runs: 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.record(z.string(), z.unknown()).nullable(),
-			})
-		)
-		.describe('Eval runs'),
 	timeline: SpanNodeSchema.nullable().optional().describe('Session timeline'),
 	route: RouteInfoSchema.optional().describe('Route information'),
 });
@@ -160,15 +141,6 @@ export const getSubcommand = createSubcommand({
 				route_id: session.route_id ?? null,
 				thread_id: session.thread_id ?? null,
 				agents: enriched.agents,
-				eval_runs: enriched.evalRuns.map((run: EvalRun) => ({
-					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,
-				})),
 				timeline: enriched.timeline,
 				route: enriched.route,
 			};
@@ -217,28 +189,6 @@ export const getSubcommand = createSubcommand({
 
 			tui.table([tableData], Object.keys(tableData), { layout: 'vertical', padStart: '  ' });
 
-			if (enriched.evalRuns.length > 0) {
-				console.log('');
-				console.log(tui.bold('Eval Runs:'));
-				const evalTableData = enriched.evalRuns.map((run: EvalRun) => ({
-					ID: run.id,
-					'Eval ID': run.eval_id,
-					Success: run.success ? tui.colorSuccess('✓') : tui.colorError('✗'),
-					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' },
-				]);
-			}
-
 			if (result.timeline) {
 				console.log('');
 				console.log(tui.bold('Timeline:'));

package/src/cmd/coder/start.ts

@@ -128,6 +128,8 @@ export const startSubcommand = createSubcommand({
 	},
 	async handler(ctx) {
 		const { opts, options } = ctx;
+		// Keep Pi's interactive install telemetry disabled for Agentuity CLI sessions.
+		process.env.PI_TELEMETRY = '0';
 
 		// Resolve working directory from optional --dir option
 		let cwd = process.cwd();

package/src/cmd/coder/tui-init.ts

@@ -43,7 +43,7 @@ export async function probeHubInitAccess(
 	try {
 		const response = await fetchImpl(`${hubHttpUrl}/api/hub/init`, {
 			headers,
-			signal: AbortSignal.timeout(5_000),
+			signal: AbortSignal.timeout(10_000),
 		});
 
 		let payload: unknown;

package/src/cmd/project/create.ts

@@ -77,7 +77,6 @@ export const createProjectSubcommand = createSubcommand({
 				.string()
 				.optional()
 				.describe('Storage action: "skip", "new", or existing bucket name'),
-			enableAuth: z.boolean().optional().describe('Enable Agentuity Auth'),
 		}),
 		response: ProjectCreateResponseSchema,
 	},
@@ -110,7 +109,6 @@ export const createProjectSubcommand = createSubcommand({
 			region,
 			database: opts.database,
 			storage: opts.storage,
-			enableAuth: opts.enableAuth,
 		});
 
 		// Exit with error code if setup failed and not in JSON mode

package/src/cmd/project/frameworks.ts

@@ -203,6 +203,7 @@ export const frameworkCatalog: FrameworkScaffold[] = [
 		description: 'React SPA with Vite bundler',
 		createCommand: (dir) => ['bunx', 'create-vite@latest', dir, '--template', 'react-ts'],
 		dependencies: ['ai', '@ai-sdk/openai', '@tanstack/react-query'],
+		devDependencies: ['tailwindcss', '@tailwindcss/vite'],
 		scripts: {
 			deploy: 'agentuity deploy',
 		},

package/src/cmd/project/index.ts

@@ -4,7 +4,6 @@ import { importSubcommand } from './import';
 import { listSubcommand } from './list';
 import { deleteSubcommand } from './delete';
 import { showSubcommand } from './show';
-import { authCommand } from './auth';
 import { addCommand } from './add';
 import { hostnameCommand } from './hostname';
 import { domainCommand } from './domain';
@@ -18,7 +17,6 @@ export const command = createCommand({
 		{ command: getCommand('project create my-agent'), description: 'Create a new project' },
 		{ command: getCommand('project import'), description: 'Import an existing project' },
 		{ command: getCommand('project list'), description: 'List all projects' },
-		{ command: getCommand('project auth init'), description: 'Set up Agentuity Auth' },
 		{ command: getCommand('project add database'), description: 'Link an existing database' },
 		{
 			command: getCommand('project add storage'),
@@ -39,7 +37,6 @@ export const command = createCommand({
 		listSubcommand,
 		deleteSubcommand,
 		showSubcommand,
-		authCommand,
 		addCommand,
 		hostnameCommand,
 		domainCommand,

package/src/cmd/project/template-flow.ts

@@ -38,13 +38,6 @@ import * as tui from '../../tui';
 import { createPrompt, note } from '../../tui';
 import type { AuthData, Config } from '../../types';
 import { getGithubBotIdentity } from '../git/api';
-import {
-	ensureAuthDependencies,
-	generateAuthFileContent,
-	generateAuthSchemaSql,
-	printIntegrationExamples,
-	runAuthMigrations,
-} from './auth/shared';
 import { scaffoldFramework, setupProject, initGitRepo } from './scaffold';
 import { frameworkCatalog, type FrameworkScaffold } from './frameworks';
 
@@ -64,7 +57,6 @@ interface CreateFlowOptions {
 	apiClient?: APIClient;
 	database?: string;
 	storage?: string;
-	enableAuth?: boolean;
 }
 
 export interface CreateFlowResult {
@@ -95,7 +87,6 @@ export async function runCreateFlow(options: CreateFlowOptions): Promise<CreateF
 		domains,
 		database: databaseOption,
 		storage: storageOption,
-		enableAuth: enableAuthOption,
 	} = options;
 
 	const isHeadless = !process.stdin.isTTY || !process.stdout.isTTY;
@@ -306,14 +297,6 @@ export async function runCreateFlow(options: CreateFlowOptions): Promise<CreateF
 		);
 	}
 
-	if (enableAuthOption && !canProvision) {
-		logger.fatal(
-			'Cannot enable Agentuity Auth without being authenticated and registering the project.\n' +
-				'Remove --no-register or omit --enable-auth flag.',
-			ErrorCode.VALIDATION_FAILED
-		);
-	}
-
 	if (canProvision) {
 		let resources: Awaited<ReturnType<typeof listResources>> | undefined;
 
@@ -527,94 +510,6 @@ export async function runCreateFlow(options: CreateFlowOptions): Promise<CreateF
 		}
 	}
 
-	// ─── Auth setup ─────────────────────────────────────────────────────────
-
-	let authEnabled = false;
-	let authDatabaseName: string | undefined;
-	let authDatabaseUrl: string | undefined;
-
-	if (enableAuthOption !== undefined) {
-		authEnabled = enableAuthOption;
-	} else if (canProvision && isInteractive) {
-		const enableAuth = await prompt.select({
-			message: 'Enable Agentuity Authentication?',
-			options: [
-				{ value: 'no', label: "No, I'll add auth later" },
-				{ value: 'yes', label: 'Yes, set up Agentuity Auth' },
-			],
-		});
-
-		if (enableAuth === 'yes') {
-			authEnabled = true;
-		}
-	}
-
-	if (authEnabled && canProvision) {
-		if (resourceEnvVars.DATABASE_URL) {
-			authDatabaseUrl = resourceEnvVars.DATABASE_URL;
-			try {
-				const dbUrl = new URL(authDatabaseUrl);
-				const dbName = dbUrl.pathname.replace(/^\/+/, '');
-				if (dbName && /^[A-Za-z0-9_-]+$/.test(dbName)) {
-					authDatabaseName = dbName;
-				}
-			} catch {
-				// Invalid URL format
-			}
-		} else {
-			const created = await tui.spinner({
-				message: 'Provisioning database for auth',
-				clearOnSuccess: true,
-				callback: async () => {
-					return createResources(catalystClient!, orgId!, region!, [{ type: 'db' }]);
-				},
-			});
-			const createdDb = created[0];
-			if (!createdDb) {
-				logger.fatal('Failed to create database for auth', ErrorCode.RESOURCE_NOT_FOUND);
-				return undefined as never;
-			}
-			authDatabaseName = createdDb.name;
-
-			if (createdDb.env) {
-				authDatabaseUrl = createdDb.env.DATABASE_URL;
-				if (!resourceEnvVars.DATABASE_URL) {
-					Object.assign(resourceEnvVars, createdDb.env);
-				}
-			}
-		}
-
-		await ensureAuthDependencies({ projectDir: dest, logger });
-
-		const authFilePath = resolve(dest, 'src', 'auth.ts');
-		if (!existsSync(authFilePath)) {
-			const srcDir = resolve(dest, 'src');
-			if (!existsSync(srcDir)) {
-				await Bun.write(resolve(srcDir, '.gitkeep'), '');
-			}
-			await Bun.write(authFilePath, generateAuthFileContent());
-			tui.success('Created src/auth.ts');
-		}
-
-		if (authDatabaseName) {
-			const sql = await tui.spinner({
-				message: 'Preparing auth database schema...',
-				clearOnSuccess: true,
-				callback: () => generateAuthSchemaSql(logger, dest),
-			});
-
-			await runAuthMigrations({
-				logger,
-				auth,
-				orgId,
-				region,
-				databaseName: authDatabaseName,
-				sql,
-				config,
-			});
-		}
-	}
-
 	// ─── Cloud registration ─────────────────────────────────────────────────
 
 	let projectId: string | undefined;
@@ -658,27 +553,9 @@ export async function runCreateFlow(options: CreateFlowOptions): Promise<CreateF
 			},
 		});
 
-		// Add auth secret
-		if (authEnabled && !resourceEnvVars.AGENTUITY_AUTH_SECRET) {
-			const devSecret = `dev-${crypto.randomUUID()}`;
-			resourceEnvVars.AGENTUITY_AUTH_SECRET = devSecret;
-		}
-
 		// Write resource env vars
 		if (Object.keys(resourceEnvVars).length > 0) {
 			await addResourceEnvVars(dest, resourceEnvVars);
-
-			if (authEnabled) {
-				if (resourceEnvVars.DATABASE_URL) {
-					tui.success('DATABASE_URL added to .env');
-				}
-				if (resourceEnvVars.AGENTUITY_AUTH_SECRET) {
-					tui.success('AGENTUITY_AUTH_SECRET added to .env');
-					tui.info(
-						`Generate one with: ${tui.muted('npx @better-auth/cli secret')} or ${tui.muted('openssl rand -hex 32')}`
-					);
-				}
-			}
 		}
 
 		// Sync env vars to cloud
@@ -772,10 +649,6 @@ export async function runCreateFlow(options: CreateFlowOptions): Promise<CreateF
 		}
 	}
 
-	if (authEnabled) {
-		printIntegrationExamples();
-	}
-
 	return {
 		projectId,
 		orgId,

package/src/cmd/project/templates/vite-react/vite.config.ts

@@ -0,0 +1,8 @@
+import { defineConfig } from 'vite';
+import react from '@vitejs/plugin-react';
+import tailwindcss from '@tailwindcss/vite';
+
+// https://vite.dev/config/
+export default defineConfig({
+	plugins: [react(), tailwindcss()],
+});

package/src/index.ts

@@ -122,10 +122,6 @@ export type {
 	AuthData,
 	CommandSchemas,
 	ResourceSelectionRule,
-	BuildPhase,
-	BuildContext,
-	AgentuityConfig,
-	WorkbenchConfig,
 } from './types';
 export { createSubcommand, createCommand } from './types';
 export type { ColorScheme } from './terminal';

package/src/onboarding/agentPrompt.ts

@@ -18,12 +18,12 @@ Agentuity is the full-stack platform for AI agents. Briefly explain to the user:
 - **Full-stack agents**: Build agents, APIs, and front-end integrations with end-to-end type safety
 - **Bun/TypeScript SDKs**: First-class developer experience with the fastest JavaScript runtime
 - **AI Gateway**: Unified access to LLMs (OpenAI-compatible SDK) with single billing—no separate API keys needed
-- **Observability**: Logs, tracing, and evals built-in so you can debug and improve agents
+- **Observability**: Logs and tracing built-in so you can debug and improve agents
 - **Production services**: Sandboxes, storage (S3-compatible), Postgres, KV, and enterprise features available as you grow
 
 We're going to be setting up the default template quickly.
 
-The default template includes AI Gateway integration, thread state persistence, structured logging, Tailwind CSS, and a local Workbench at \`/workbench\` for testing agents.
+The default template includes AI Gateway integration, thread state persistence, structured logging, and Tailwind CSS.
 
 ---
 
@@ -107,7 +107,6 @@ agentuity dev
 
 **What happens:**
 - **Local server** starts at \`http://localhost:3500\` — this is where your APIs and agents are served
-- **Workbench** available at \`http://localhost:3500/workbench\` — a built-in UI for testing and interacting with your agents directly, without needing a frontend
 - **Public tunnel URL** is automatically created — the CLI will display a public URL that tunnels to your local server, useful for testing webhooks or sharing with others
 - **Hot reload** enabled — code changes reflect immediately
 
@@ -116,8 +115,7 @@ agentuity dev
 > "The dev server is now running! Here's what to try:
 >
 > 1. Open **http://localhost:3500** to see the app
-> 2. Open **http://localhost:3500/workbench** to interact with your agents (this is a key feature!)
-> 3. The public tunnel URL shown in the terminal can be shared with others
+> 2. The public tunnel URL shown in the terminal can be shared with others
 >
 > Take a few minutes to explore. When you're ready to deploy to production, let me know!"
 
@@ -179,7 +177,6 @@ After deployment, explain what they now have:
 | **AI Gateway** | OpenAI-compatible SDK routed through Agentuity—unified billing, no separate API keys |
 | **Thread State** | Conversations and agent state persist automatically for multi-turn flows |
 | **Structured Logging** | Logs and traces captured for debugging and analytics |
-| **Workbench** | Local UI at \`/workbench\` for testing agents without a frontend |
 | **Tailwind CSS** | Pre-configured styling for the frontend |
 | **Type Safety** | End-to-end types from agent schemas to API routes to frontend |
 
@@ -199,7 +196,7 @@ After successful deployment, guide the user through these recommendations:
 - Get help, see examples, share what you're building
 
 ### 3. Explore the Dashboard
-- **Observability**: View logs, traces, and evals for your deployment
+- **Observability**: View logs and traces for your deployment
 - **Deployments**: See version history with rollback options
 - **Analytics**: Monitor usage and performance
 
@@ -240,7 +237,7 @@ The SDK makes it easy to:
 **Onboarding is successful when the user has:**
 
 1. ✅ **CLI installed** and authenticated
-2. ✅ **Local dev environment running** — they've seen \`localhost:3500\` and tried the Workbench
+2. ✅ **Local dev environment running** — they've seen \`localhost:3500\`
 3. ✅ **First deployment complete** — they have a live production URL
 4. ✅ **Free credits earned** — they know they've been rewarded and can keep building
 5. ✅ **Clear next steps** — they know about Discord, the dashboard, and how to extend their project

package/src/runtime-bootstrap.md

@@ -115,8 +115,7 @@ For config files:
 
 This utility is used by:
 
-- `sdk/apps/testing/integration-suite/app.ts`
-- `sdk/apps/testing/cloud-deployment/app.ts`
+- `sdk/tests/integration/integration-suite/app.ts`
 
 It reuses existing infrastructure from the CLI:
 
@@ -149,7 +148,7 @@ To verify it works:
 export AGENTUITY_PROFILE=local
 
 # Build and run
-cd sdk/apps/testing/integration-suite
+cd sdk/tests/integration/integration-suite
 bun run build
 cd .agentuity && bun run app.js