@agentuity/cli 2.0.10 → 3.0.0-alpha.0

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@agentuity/cli",
-	"version": "2.0.10",
+	"version": "3.0.0-alpha.0",
 	"license": "Apache-2.0",
 	"author": "Agentuity employees and contributors",
 	"type": "module",
@@ -41,11 +41,11 @@
 		"prepublishOnly": "bun run clean && bun run build"
 	},
 	"dependencies": {
-		"@agentuity/auth": "2.0.10",
-		"@agentuity/coder-tui": "2.0.10",
-		"@agentuity/core": "2.0.10",
-		"@agentuity/frontend": "2.0.10",
-		"@agentuity/server": "2.0.10",
+		"@agentuity/auth": "3.0.0-alpha.0",
+		"@agentuity/coder-tui": "3.0.0-alpha.0",
+		"@agentuity/core": "3.0.0-alpha.0",
+		"@agentuity/frontend": "3.0.0-alpha.0",
+		"@agentuity/server": "3.0.0-alpha.0",
 		"@datasert/cronjs-parser": "^1.4.0",
 		"@vitejs/plugin-react": "^5.1.2",
 		"acorn-loose": "^8.5.2",
@@ -64,7 +64,7 @@
 		"zod": "^4.3.5"
 	},
 	"devDependencies": {
-		"@agentuity/test-utils": "2.0.10",
+		"@agentuity/test-utils": "3.0.0-alpha.0",
 		"@types/adm-zip": "^0.5.7",
 		"@types/archiver": "^7.0.0",
 		"@types/bun": "latest",
@@ -77,5 +77,10 @@
 	"publishConfig": {
 		"access": "public"
 	},
-	"sideEffects": false
+	"sideEffects": false,
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/agentuity/sdk.git",
+		"directory": "packages/cli"
+	}
 }

package/src/cmd/ai/prompt/index.ts

@@ -1,27 +1,22 @@
 import { createCommand } from '../../../types';
 import { llmSubcommand } from './llm';
 import { apiSubcommand } from './api';
-import { agentSubcommand } from './agent';
 import { webSubcommand } from './web';
 import { getCommand } from '../../../command-prefix';
 
 export const promptCommand = createCommand({
 	name: 'prompt',
-	description: 'Generate prompts for LLMs and agents',
+	description: 'Generate prompts for LLMs',
 	tags: ['read-only', 'fast'],
 	examples: [
 		{ command: getCommand('ai prompt llm'), description: 'Generate LLM-specific prompt' },
-		{
-			command: getCommand('ai prompt agent'),
-			description: 'Generate LLM-specific prompt for Agents',
-		},
 		{
 			command: getCommand('ai prompt api'),
 			description: 'Generate LLM-specific prompt for APIs',
 		},
 		{ command: getCommand('ai prompt web'), description: 'Generate LLM-specific prompt for Web' },
 	],
-	subcommands: [agentSubcommand, webSubcommand, llmSubcommand, apiSubcommand],
+	subcommands: [webSubcommand, llmSubcommand, apiSubcommand],
 });
 
 export default promptCommand;

package/src/cmd/build/adapters/generic.ts

@@ -0,0 +1,239 @@
+/**
+ * Generic build adapter.
+ *
+ * Handles any JS framework by:
+ * 1. Installing dependencies
+ * 2. Running the project's build script
+ * 3. Copying the build output to the output directory
+ *
+ * This is the fallback for frameworks without a specific adapter,
+ * and is also the base logic that specific adapters build on.
+ */
+
+import { basename, join, resolve, relative } from 'node:path';
+import { cpSync, existsSync, mkdirSync, readdirSync } from 'node:fs';
+import type { BuildAdapter, BuildAdapterOptions, BuildResult } from './types';
+import { getRunCommand } from '../detect/util';
+
+/**
+ * Run a shell command and return exit code.
+ */
+async function runCommand(
+	cmd: string[],
+	cwd: string,
+	env?: Record<string, string>
+): Promise<{ exitCode: number; stdout: string; stderr: string }> {
+	const proc = Bun.spawn(cmd, {
+		cwd,
+		env: { ...process.env, ...env },
+		stdout: 'pipe',
+		stderr: 'pipe',
+	});
+
+	const [stdout, stderr] = await Promise.all([
+		new Response(proc.stdout).text(),
+		new Response(proc.stderr).text(),
+	]);
+
+	await proc.exited;
+
+	return {
+		exitCode: proc.exitCode ?? 1,
+		stdout,
+		stderr,
+	};
+}
+
+/**
+ * Install dependencies using the detected package manager.
+ */
+export async function installDependencies(
+	projectDir: string,
+	packageManager: string,
+	logger: { debug: (...args: unknown[]) => void }
+): Promise<void> {
+	let cmd: string[];
+	switch (packageManager) {
+		case 'bun':
+			cmd = ['bun', 'install'];
+			break;
+		case 'pnpm':
+			cmd = ['pnpm', 'install', '--frozen-lockfile'];
+			break;
+		case 'yarn':
+			cmd = ['yarn', 'install', '--frozen-lockfile'];
+			break;
+		default:
+			cmd = ['npm', 'ci'];
+			break;
+	}
+
+	logger.debug(`Installing dependencies with: ${cmd.join(' ')}`);
+
+	const result = await runCommand(cmd, projectDir);
+	if (result.exitCode !== 0) {
+		throw new Error(
+			`Dependency installation failed (exit ${result.exitCode}):\n${result.stderr}`
+		);
+	}
+}
+
+/**
+ * Run the framework's build command.
+ */
+export async function runBuildCommand(
+	projectDir: string,
+	buildCommand: string,
+	packageManager: string,
+	buildEnv?: Record<string, string>,
+	logger?: { debug: (...args: unknown[]) => void }
+): Promise<{ stdout: string; stderr: string }> {
+	// If it's a package.json script name, use the package manager's run command
+	// If it contains spaces or special chars, it's likely a direct command
+	const isScriptName = /^[a-zA-Z0-9_:-]+$/.test(buildCommand);
+
+	let cmd: string[];
+	if (isScriptName && buildCommand !== '__agentuity_internal__') {
+		const runCmd = getRunCommand(packageManager as 'bun' | 'npm' | 'pnpm' | 'yarn');
+		cmd = runCmd.split(' ').concat(buildCommand);
+	} else {
+		cmd = ['sh', '-c', buildCommand];
+	}
+
+	logger?.debug(`Running build command: ${cmd.join(' ')}`);
+
+	const result = await runCommand(cmd, projectDir, buildEnv);
+	if (result.exitCode !== 0) {
+		throw new Error(`Build failed (exit ${result.exitCode}):\n${result.stderr || result.stdout}`);
+	}
+
+	return { stdout: result.stdout, stderr: result.stderr };
+}
+
+export const genericAdapter: BuildAdapter = {
+	name: 'generic',
+
+	async build(options: BuildAdapterOptions): Promise<BuildResult> {
+		const { projectDir, framework, outputDir, logger } = options;
+		const started = Date.now();
+		const logs: string[] = [];
+
+		// Step 1: Install dependencies
+		logger.debug('Installing dependencies...');
+		const installStart = Date.now();
+		await installDependencies(projectDir, framework.packageManager, logger);
+		logs.push(`✓ Dependencies installed in ${Date.now() - installStart}ms`);
+
+		// Step 2: Run the build command
+		if (framework.buildCommand && framework.buildCommand !== '__agentuity_internal__') {
+			logger.debug(`Running build: ${framework.buildCommand}`);
+			const buildStart = Date.now();
+			await runBuildCommand(
+				projectDir,
+				framework.buildCommand,
+				framework.packageManager,
+				framework.buildEnv,
+				logger
+			);
+			logs.push(`✓ Build completed in ${Date.now() - buildStart}ms`);
+		}
+
+		// Step 3: Copy build output to output directory
+		const buildOutputPath = resolve(projectDir, framework.buildOutput);
+		const resolvedOutputDir = resolve(outputDir);
+
+		// Copy build output to the output directory when they differ.
+		// When buildOutput is '.' (project root), the output dir is a subdirectory
+		// of the source, so we iterate entries to avoid cpSync's self-copy check.
+		const shouldCopy = existsSync(buildOutputPath) && buildOutputPath !== resolvedOutputDir;
+
+		if (shouldCopy) {
+			logger.debug(`Copying build output from ${buildOutputPath} to ${resolvedOutputDir}`);
+			mkdirSync(resolvedOutputDir, { recursive: true });
+
+			// Skip directories that shouldn't be deployed
+			const skipEntries = new Set([
+				'node_modules',
+				'.git',
+				'.env',
+				basename(resolvedOutputDir), // e.g., '.agentuity'
+			]);
+
+			const entries = readdirSync(buildOutputPath);
+			for (const entry of entries) {
+				if (skipEntries.has(entry)) continue;
+				const srcPath = join(buildOutputPath, entry);
+				const dstPath = join(resolvedOutputDir, entry);
+				cpSync(srcPath, dstPath, { recursive: true });
+			}
+		} else {
+			// Ensure output dir exists even when we skip the copy
+			mkdirSync(resolvedOutputDir, { recursive: true });
+		}
+
+		// Step 4: Determine start command — inject static file server if none exists
+		let { startCommand, serverEntry } = framework;
+
+		if (!startCommand) {
+			// No start command (static-only build) — inject a minimal file server
+			const { injectStaticServer } = await import('./static-server');
+			const injected = injectStaticServer(outputDir);
+			startCommand = injected.startCommand;
+			serverEntry = injected.serverEntry;
+			logs.push('✓ Injected static file server (no start script found)');
+		}
+
+		// Step 5: Copy package.json and node_modules for runtime
+		const pkgJsonSrc = join(projectDir, 'package.json');
+		const pkgJsonDst = join(outputDir, 'package.json');
+		if (existsSync(pkgJsonSrc) && !existsSync(pkgJsonDst)) {
+			cpSync(pkgJsonSrc, pkgJsonDst);
+		}
+
+		const nodeModulesSrc = join(projectDir, 'node_modules');
+		const nodeModulesDst = join(outputDir, 'node_modules');
+		if (existsSync(nodeModulesSrc) && !existsSync(nodeModulesDst)) {
+			logger.debug('Copying node_modules for runtime dependencies...');
+			cpSync(nodeModulesSrc, nodeModulesDst, { recursive: true });
+		}
+
+		// Step 6: Resolve static asset directory for CDN upload
+		// staticDir is relative to the project root (set by framework detection).
+		// If it matches buildOutput, the files are already in outputDir from the copy.
+		// Otherwise, copy the static assets into the output so deploy can find them.
+		let resolvedStaticDir: string | undefined;
+
+		if (framework.staticDir) {
+			const staticSrcPath = resolve(projectDir, framework.staticDir);
+			const buildOutputPath = resolve(projectDir, framework.buildOutput);
+
+			// Check if the static dir is inside the build output (already copied)
+			if (staticSrcPath.startsWith(buildOutputPath + '/') || staticSrcPath === buildOutputPath) {
+				// Static assets are within the copied build output
+				const relativeToOutput = relative(buildOutputPath, staticSrcPath);
+				resolvedStaticDir = relativeToOutput
+					? join(resolvedOutputDir, relativeToOutput)
+					: resolvedOutputDir;
+			} else if (existsSync(staticSrcPath)) {
+				// Static assets are outside the build output — copy them into the output
+				const staticDstPath = join(resolvedOutputDir, framework.staticDir);
+				logger.debug(`Copying static assets from ${staticSrcPath} to ${staticDstPath}`);
+				mkdirSync(staticDstPath, { recursive: true });
+				cpSync(staticSrcPath, staticDstPath, { recursive: true });
+				resolvedStaticDir = staticDstPath;
+				logs.push(`✓ Copied static assets from ${framework.staticDir}`);
+			}
+		}
+
+		return {
+			outputDir,
+			startCommand,
+			serverEntry,
+			staticDir:
+				resolvedStaticDir && existsSync(resolvedStaticDir) ? resolvedStaticDir : undefined,
+			port: framework.port,
+			duration: Date.now() - started,
+			logs,
+		};
+	},
+};

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

@@ -0,0 +1,30 @@
+/**
+ * Build Adapter Registry
+ *
+ * Maps detected framework names to their build adapters.
+ * Specific adapters handle framework-specific concerns (e.g., Next.js standalone mode).
+ * Frameworks without a specific adapter fall through to the generic adapter.
+ */
+
+import type { BuildAdapter } from './types';
+import { genericAdapter } from './generic';
+import { nextjsAdapter } from './nextjs';
+
+/**
+ * Registry of framework-specific build adapters.
+ * Frameworks not in this map use the generic adapter.
+ */
+const adapters: Record<string, BuildAdapter> = {
+	nextjs: nextjsAdapter,
+};
+
+/**
+ * Get the build adapter for a detected framework.
+ * Falls back to the generic adapter if no specific one exists.
+ */
+export function getAdapter(frameworkName: string): BuildAdapter {
+	return adapters[frameworkName] ?? genericAdapter;
+}
+
+// Re-export types
+export type { BuildAdapter, BuildAdapterOptions, BuildResult } from './types';

package/src/cmd/build/adapters/nextjs.ts

@@ -0,0 +1,146 @@
+/**
+ * Next.js build adapter.
+ *
+ * Handles Next.js-specific build concerns:
+ * 1. Ensures standalone output mode is configured
+ * 2. Copies the standalone directory + static assets to output
+ * 3. Sets up the correct start command
+ */
+
+import { join } from 'node:path';
+import { cpSync, existsSync, mkdirSync, readFileSync } from 'node:fs';
+import type { BuildAdapter, BuildAdapterOptions, BuildResult } from './types';
+import { installDependencies, runBuildCommand } from './generic';
+
+/**
+ * Ensure next.config has output: 'standalone'.
+ *
+ * Rather than modifying the user's config file, we set the NEXT_OUTPUT env var
+ * which can be read in next.config.js, or we check if standalone is already configured.
+ * As a fallback, we also set the experimental config via env.
+ */
+function getNextBuildEnv(): Record<string, string> {
+	return {
+		// Signal to the build that we want standalone output
+		NEXT_PRIVATE_STANDALONE: 'true',
+	};
+}
+
+export const nextjsAdapter: BuildAdapter = {
+	name: 'nextjs',
+
+	async build(options: BuildAdapterOptions): Promise<BuildResult> {
+		const { projectDir, framework, outputDir, logger } = options;
+		const started = Date.now();
+		const logs: string[] = [];
+
+		// Step 1: Install dependencies
+		logger.debug('Installing dependencies...');
+		const installStart = Date.now();
+		await installDependencies(projectDir, framework.packageManager, logger);
+		logs.push(`✓ Dependencies installed in ${Date.now() - installStart}ms`);
+
+		// Step 2: Check if standalone mode is configured
+		const nextConfigPath = await findNextConfig(projectDir);
+		let standaloneConfigured = false;
+		if (nextConfigPath) {
+			const content = readFileSync(nextConfigPath, 'utf-8');
+			standaloneConfigured =
+				content.includes("'standalone'") || content.includes('"standalone"');
+		}
+
+		if (!standaloneConfigured) {
+			logger.debug(
+				'Standalone output not detected in next.config — setting NEXT_PRIVATE_STANDALONE=true'
+			);
+		}
+
+		// Step 3: Run the build with standalone env
+		const buildEnv = {
+			...framework.buildEnv,
+			...getNextBuildEnv(),
+		};
+
+		logger.debug(`Running Next.js build: ${framework.buildCommand}`);
+		const buildStart = Date.now();
+		await runBuildCommand(
+			projectDir,
+			framework.buildCommand,
+			framework.packageManager,
+			buildEnv,
+			logger
+		);
+		logs.push(`✓ Next.js build completed in ${Date.now() - buildStart}ms`);
+
+		// Step 4: Package the standalone output
+		mkdirSync(outputDir, { recursive: true });
+
+		const standalonePath = join(projectDir, '.next', 'standalone');
+		const staticPath = join(projectDir, '.next', 'static');
+		const publicPath = join(projectDir, 'public');
+
+		if (existsSync(standalonePath)) {
+			// Copy standalone server
+			logger.debug('Copying standalone server...');
+			cpSync(standalonePath, outputDir, { recursive: true });
+
+			// Copy static assets into .next/static within the output
+			if (existsSync(staticPath)) {
+				const staticDst = join(outputDir, '.next', 'static');
+				mkdirSync(staticDst, { recursive: true });
+				cpSync(staticPath, staticDst, { recursive: true });
+			}
+
+			// Copy public assets
+			if (existsSync(publicPath)) {
+				const publicDst = join(outputDir, 'public');
+				mkdirSync(publicDst, { recursive: true });
+				cpSync(publicPath, publicDst, { recursive: true });
+			}
+
+			logs.push('✓ Standalone output packaged');
+		} else {
+			// Fallback: copy the whole .next directory
+			logger.debug('No standalone output found — copying full .next directory');
+			const nextDst = join(outputDir, '.next');
+			cpSync(join(projectDir, '.next'), nextDst, { recursive: true });
+
+			// Copy package.json and node_modules
+			cpSync(join(projectDir, 'package.json'), join(outputDir, 'package.json'));
+			if (existsSync(join(projectDir, 'node_modules'))) {
+				cpSync(join(projectDir, 'node_modules'), join(outputDir, 'node_modules'), {
+					recursive: true,
+				});
+			}
+
+			logs.push('⚠ No standalone output — using full build (consider enabling standalone mode)');
+		}
+
+		// Determine start command based on what we have
+		const hasStandalone = existsSync(join(outputDir, 'server.js'));
+		const startCommand = hasStandalone ? 'node server.js' : 'node node_modules/.bin/next start';
+
+		return {
+			outputDir,
+			startCommand,
+			serverEntry: hasStandalone ? 'server.js' : undefined,
+			staticDir: existsSync(join(outputDir, '.next', 'static'))
+				? join(outputDir, '.next', 'static')
+				: undefined,
+			port: framework.port ?? 3000,
+			duration: Date.now() - started,
+			logs,
+		};
+	},
+};
+
+async function findNextConfig(projectDir: string): Promise<string | null> {
+	const candidates = ['next.config.js', 'next.config.mjs', 'next.config.ts', 'next.config.cjs'];
+
+	for (const name of candidates) {
+		const path = join(projectDir, name);
+		if (existsSync(path)) return path;
+	}
+
+	return null;
+}

package/src/cmd/build/adapters/static-server.ts

@@ -0,0 +1,143 @@
+/**
+ * Static file server injector.
+ *
+ * When a framework has no start command (e.g., static-only builds from
+ * Vite SPA, Gatsby, Eleventy), this module injects a minimal file server
+ * so there's always a valid start command in launch.json.
+ *
+ * The server is a small Node.js http script that:
+ * - Serves files from the build output directory
+ * - Returns index.html for non-file routes (SPA support)
+ * - Sets appropriate cache headers
+ */
+
+import { join } from 'node:path';
+import { writeFileSync, mkdirSync } from 'node:fs';
+
+/**
+ * The static server script, inlined as a string.
+ * Uses Bun.serve which is available in the deployment runtime.
+ * Falls back to a Node.js http server if Bun is not available.
+ */
+const STATIC_SERVER_SCRIPT = `#!/usr/bin/env node
+/**
+ * Minimal static file server — auto-generated by Agentuity build.
+ * Serves files from the current directory with SPA fallback.
+ */
+const path = require('path');
+const fs = require('fs');
+const http = require('http');
+
+const PORT = parseInt(process.env.PORT || '3000', 10);
+const ROOT = __dirname;
+
+const MIME_TYPES = {
+   '.html': 'text/html',
+   '.js': 'application/javascript',
+   '.css': 'text/css',
+   '.json': 'application/json',
+   '.png': 'image/png',
+   '.jpg': 'image/jpeg',
+   '.jpeg': 'image/jpeg',
+   '.gif': 'image/gif',
+   '.svg': 'image/svg+xml',
+   '.ico': 'image/x-icon',
+   '.webp': 'image/webp',
+   '.avif': 'image/avif',
+   '.woff': 'font/woff',
+   '.woff2': 'font/woff2',
+   '.ttf': 'font/ttf',
+   '.otf': 'font/otf',
+   '.map': 'application/json',
+   '.txt': 'text/plain',
+   '.xml': 'application/xml',
+   '.webmanifest': 'application/manifest+json',
+};
+
+function getMimeType(filePath) {
+   const ext = path.extname(filePath).toLowerCase();
+   return MIME_TYPES[ext] || 'application/octet-stream';
+}
+
+function isImmutableAsset(filePath) {
+   // Hashed assets from bundlers (e.g., main-abc123.js)
+   return /\\.[a-f0-9]{8,}\\./i.test(filePath);
+}
+
+const server = http.createServer((req, res) => {
+   const url = new URL(req.url, \`http://localhost:\${PORT}\`);
+   let filePath = path.join(ROOT, url.pathname);
+
+   // Security: prevent directory traversal
+   if (!filePath.startsWith(ROOT)) {
+      res.writeHead(403);
+      res.end('Forbidden');
+      return;
+   }
+
+   // Try to serve the exact file
+   if (fs.existsSync(filePath) && fs.statSync(filePath).isFile()) {
+      const content = fs.readFileSync(filePath);
+      const mime = getMimeType(filePath);
+      const headers = { 'Content-Type': mime };
+
+      // Immutable caching for hashed assets
+      if (isImmutableAsset(filePath)) {
+         headers['Cache-Control'] = 'public, max-age=31536000, immutable';
+      } else {
+         headers['Cache-Control'] = 'public, max-age=0, must-revalidate';
+      }
+
+      res.writeHead(200, headers);
+      res.end(content);
+      return;
+   }
+
+   // Try index.html in the directory
+   if (fs.existsSync(filePath) && fs.statSync(filePath).isDirectory()) {
+      const indexPath = path.join(filePath, 'index.html');
+      if (fs.existsSync(indexPath)) {
+         const content = fs.readFileSync(indexPath);
+         res.writeHead(200, { 'Content-Type': 'text/html', 'Cache-Control': 'public, max-age=0, must-revalidate' });
+         res.end(content);
+         return;
+      }
+   }
+
+   // SPA fallback: serve root index.html for non-file routes
+   const indexPath = path.join(ROOT, 'index.html');
+   if (fs.existsSync(indexPath)) {
+      const content = fs.readFileSync(indexPath);
+      res.writeHead(200, { 'Content-Type': 'text/html', 'Cache-Control': 'public, max-age=0, must-revalidate' });
+      res.end(content);
+      return;
+   }
+
+   res.writeHead(404);
+   res.end('Not Found');
+});
+
+server.listen(PORT, () => {
+   console.log(\`Static server listening on port \${PORT}\`);
+});
+`;
+
+/**
+ * Inject a static file server into the build output directory.
+ *
+ * @param outputDir - Absolute path to the build output
+ * @returns The start command for the injected server
+ */
+export function injectStaticServer(outputDir: string): {
+	startCommand: string;
+	serverEntry: string;
+} {
+	mkdirSync(outputDir, { recursive: true });
+	const serverPath = join(outputDir, '_serve.js');
+	writeFileSync(serverPath, STATIC_SERVER_SCRIPT, 'utf-8');
+
+	return {
+		startCommand: 'node _serve.js',
+		serverEntry: '_serve.js',
+	};
+}