@agentuity/cli 0.0.12 → 0.0.15

package/src/cmd/dev/index.ts

@@ -1,9 +1,9 @@
-import { createCommand } from '@/types';
+import { createCommand } from '../../types';
 import { z } from 'zod';
-import { resolve } from 'node:path';
+import { resolve, join } from 'node:path';
 import { bundle } from '../bundle/bundler';
-import { existsSync } from 'node:fs';
-import * as tui from '@/tui';
+import { existsSync, FSWatcher, watch } from 'node:fs';
+import * as tui from '../../tui';
 
 export const command = createCommand({
 	name: 'dev',
@@ -13,69 +13,156 @@ export const command = createCommand({
 			dir: z.string().optional().describe('Root directory of the project'),
 		}),
 	},
+	optionalAuth: 'Continue without an account (local only)',
 
 	async handler(ctx) {
-		const { opts } = ctx;
+		const { opts, logger } = ctx;
+
 		const rootDir = resolve(opts.dir || process.cwd());
+		const appTs = join(rootDir, 'app.ts');
+		const srcDir = join(rootDir, 'src');
+		const mustHaves = [join(rootDir, 'package.json'), appTs, srcDir];
+		const missing: string[] = [];
+
+		for (const filename of mustHaves) {
+			if (!existsSync(filename)) {
+				missing.push(filename);
+			}
+		}
+
+		if (missing.length) {
+			tui.error(`${rootDir} does not appear to be a valid Agentuity project`);
+			for (const filename of missing) {
+				tui.bullet(`Missing ${filename}`);
+			}
+			process.exit(1);
+		}
+
 		const agentuityDir = resolve(rootDir, '.agentuity');
 		const appPath = resolve(agentuityDir, 'app.js');
 
-		try {
-			await tui.spinner('Building project...', async () => {
-				await bundle({
-					rootDir,
-					dev: true,
-				});
-			});
+		const watches = [appTs, srcDir];
+		const watchers: FSWatcher[] = [];
+		let failures = 0;
+		let running = false;
+		let pid = 0;
+		let failed = false;
+		let devServer: Bun.Subprocess | undefined;
 
-			tui.success('Build complete');
+		function failure(msg: string) {
+			failed = true;
+			failures++;
+			if (failures >= 5) {
+				tui.error(msg);
+				tui.fatal('too many failures, exiting');
+			} else {
+				setImmediate(() => tui.error(msg));
+			}
+		}
 
-			if (!existsSync(appPath)) {
-				tui.error(`App file not found: ${appPath}`);
-				process.exit(1);
+		const kill = () => {
+			running = false;
+			try {
+				// Kill the process group (negative PID kills entire group)
+				process.kill(-pid, 'SIGTERM');
+			} catch {
+				// Fallback: kill the direct process
+				try {
+					if (devServer) {
+						devServer.kill();
+					}
+				} catch {
+					// Ignore if already dead
+				}
+			} finally {
+				devServer = undefined;
 			}
+		};
 
-			tui.info('Starting development server...');
-
-			// Use shell to run in a process group for proper cleanup
-			// The 'exec' ensures the shell is replaced by the actual process
-			const devServer = Bun.spawn(['sh', '-c', `exec bun run "${appPath}"`], {
-				cwd: rootDir,
-				stdout: 'inherit',
-				stderr: 'inherit',
-				stdin: 'inherit',
-			});
-
-			// Handle signals to ensure entire process tree is killed
-			const cleanup = () => {
-				if (devServer.pid) {
-					try {
-						// Kill the process group (negative PID kills entire group)
-						process.kill(-devServer.pid, 'SIGTERM');
-					} catch {
-						// Fallback: kill the direct process
+		// Handle signals to ensure entire process tree is killed
+		const cleanup = () => {
+			if (pid && running) {
+				kill();
+			}
+			for (const watcher of watchers) {
+				watcher.close();
+			}
+			watchers.length = 0;
+			process.exit(0);
+		};
+
+		process.on('SIGINT', cleanup);
+		process.on('SIGTERM', cleanup);
+
+		async function restart() {
+			try {
+				if (running) {
+					tui.info('Restarting on file change');
+					kill();
+					return;
+				}
+				await Promise.all([
+					tui.runCommand({
+						command: 'tsc',
+						cmd: ['bunx', 'tsc', '--noEmit'],
+						cwd: rootDir,
+						clearOnSuccess: true,
+						truncate: false,
+						maxLinesOutput: 1,
+						maxLinesOnFailure: 15,
+					}),
+					tui.spinner('Building project', async () => {
 						try {
-							devServer.kill();
+							await bundle({
+								rootDir,
+								dev: true,
+							});
 						} catch {
-							// Ignore if already dead
+							failure('Build failed');
 						}
-					}
+					}),
+				]);
+
+				if (failed) {
+					return;
 				}
-				process.exit(0);
-			};
 
-			process.on('SIGINT', cleanup);
-			process.on('SIGTERM', cleanup);
+				if (!existsSync(appPath)) {
+					failure(`App file not found: ${appPath}`);
+					return;
+				}
 
-			const exitCode = await devServer.exited;
-			process.exit(exitCode);
-		} catch (error) {
-			if (error instanceof Error) {
-				tui.error(`Dev server failed: ${error.message}`);
-			} else {
-				tui.error('Dev server failed');
+				// Use shell to run in a process group for proper cleanup
+				// The 'exec' ensures the shell is replaced by the actual process
+				const devServer = Bun.spawn(['sh', '-c', `exec bun run "${appPath}"`], {
+					cwd: rootDir,
+					stdout: 'inherit',
+					stderr: 'inherit',
+					stdin: 'inherit',
+				});
+
+				running = true;
+				failed = false;
+				pid = devServer.pid;
+
+				const exitCode = await devServer.exited;
+				if (exitCode === 0) {
+					process.exit(exitCode);
+				}
+			} catch (error) {
+				if (error instanceof Error) {
+					failure(`Dev server failed: ${error.message}`);
+				} else {
+					failure('Dev server failed');
+				}
+			} finally {
+				running = false;
 			}
-			process.exit(1);
+		}
+		await restart();
+		for (const filename of watches) {
+			logger.trace('watching %s', filename);
+			watchers.push(watch(filename, { recursive: true }, restart));
 		}
 	},
 });

package/src/cmd/example/create-user.ts

@@ -1,4 +1,4 @@
-import { createSubcommand } from '@/types';
+import { createSubcommand } from '../../types';
 import { z } from 'zod';
 
 export const createUserSubcommand = createSubcommand({

package/src/cmd/example/create.ts

@@ -1,4 +1,4 @@
-import { createSubcommand } from '@/types';
+import { createSubcommand } from '../../types';
 import { z } from 'zod';
 
 export const createCommand = createSubcommand({

package/src/cmd/example/deploy.ts

@@ -1,4 +1,4 @@
-import { createSubcommand } from '@/types';
+import { createSubcommand } from '../../types';
 import { z } from 'zod';
 
 export const deploySubcommand = createSubcommand({

package/src/cmd/example/index.ts

@@ -1,4 +1,4 @@
-import { createCommand } from '@/types';
+import { createCommand } from '../../types';
 import { createCommand as createSubCmd } from './create';
 import { listSubcommand } from './list';
 import { stepsSubcommand } from './steps';
@@ -8,6 +8,7 @@ import { versionSubcommand } from './version';
 import { createUserSubcommand } from './create-user';
 import { runCommandSubcommand } from './run-command';
 import { soundSubcommand } from './sound';
+import { optionalAuthSubcommand } from './optional-auth';
 
 export const command = createCommand({
 	name: 'example',
@@ -23,5 +24,6 @@ export const command = createCommand({
 		createUserSubcommand,
 		runCommandSubcommand,
 		soundSubcommand,
+		optionalAuthSubcommand,
 	],
 });

package/src/cmd/example/list.ts

@@ -1,4 +1,4 @@
-import { createSubcommand } from '@/types';
+import { createSubcommand } from '../../types';
 import { z } from 'zod';
 
 export const listSubcommand = createSubcommand({

package/src/cmd/example/optional-auth.ts

@@ -0,0 +1,38 @@
+import type { SubcommandDefinition, CommandContext, AuthData } from '../../types';
+import * as tui from '../../tui';
+
+export const optionalAuthSubcommand: SubcommandDefinition = {
+	name: 'optional-auth',
+	description: 'Test optional authentication flow',
+	optionalAuth: 'Continue with local features only',
+	handler: async (ctx: CommandContext) => {
+		tui.newline();
+
+		// Type guard to check if auth is present
+		const ctxWithAuth = ctx as CommandContext<true>;
+		if ('auth' in ctx && ctxWithAuth.auth) {
+			const auth = ctxWithAuth.auth as AuthData;
+			// User chose to authenticate
+			tui.success('You are authenticated!');
+			tui.info(`User ID: ${auth.userId}`);
+			tui.info(`Session expires: ${auth.expires.toLocaleString()}`);
+			tui.newline();
+			tui.info('You can now access cloud features:');
+			tui.bullet('Deploy to production');
+			tui.bullet('Access remote resources');
+			tui.bullet('View team analytics');
+		} else {
+			// User chose to continue without auth
+			tui.info('Running in local mode (no authentication)');
+			tui.newline();
+			tui.info('Available local features:');
+			tui.bullet('Local development');
+			tui.bullet('Offline testing');
+			tui.bullet('Build and bundle');
+			tui.newline();
+			tui.warning('Some cloud features are unavailable without authentication');
+		}
+
+		tui.newline();
+	},
+};

package/src/cmd/example/run-command.ts

@@ -1,5 +1,5 @@
-import { createSubcommand } from '@/types';
-import * as tui from '@/tui';
+import { createSubcommand } from '../../types';
+import * as tui from '../../tui';
 
 export const runCommandSubcommand = createSubcommand({
 	name: 'run-command',

package/src/cmd/example/sound.ts

@@ -1,6 +1,6 @@
 import type { SubcommandDefinition } from '../../types';
-import * as tui from '@/tui';
-import { playSound } from '@/sound';
+import * as tui from '../../tui';
+import { playSound } from '../../sound';
 
 export const soundSubcommand: SubcommandDefinition = {
 	name: 'sound',

package/src/cmd/example/spinner.ts

@@ -1,5 +1,5 @@
-import { createSubcommand } from '@/types';
-import * as tui from '@/tui';
+import { createSubcommand } from '../../types';
+import * as tui from '../../tui';
 
 export const spinnerSubcommand = createSubcommand({
 	name: 'spinner',

package/src/cmd/example/steps.ts

@@ -1,5 +1,5 @@
-import { createSubcommand } from '@/types';
-import { runSteps, stepSuccess, stepSkipped, stepError } from '@/steps';
+import { createSubcommand } from '../../types';
+import { runSteps, stepSuccess, stepSkipped, stepError } from '../../steps';
 
 export const stepsSubcommand = createSubcommand({
 	name: 'steps',

package/src/cmd/example/version.ts

@@ -1,4 +1,4 @@
-import { createSubcommand } from '@/types';
+import { createSubcommand } from '../../types';
 
 export const versionSubcommand = createSubcommand({
 	name: 'version',

package/src/cmd/profile/create.ts

@@ -1,14 +1,14 @@
-import { createSubcommand } from '@/types';
+import { createSubcommand } from '../../types';
 import { z } from 'zod';
 import {
 	fetchProfiles,
 	getDefaultConfigDir,
 	ensureConfigDir,
 	generateYAMLTemplate,
-} from '@/config';
+} from '../../config';
 import { join } from 'node:path';
 import { writeFile } from 'node:fs/promises';
-import * as tui from '@/tui';
+import * as tui from '../../tui';
 
 const PROFILE_NAME_REGEX = /^[\w_-]{3,}$/;
 

package/src/cmd/profile/delete.ts

@@ -1,8 +1,8 @@
-import { createSubcommand } from '@/types';
+import { createSubcommand } from '../../types';
 import { z } from 'zod';
-import { fetchProfiles } from '@/config';
+import { fetchProfiles } from '../../config';
 import { unlink } from 'node:fs/promises';
-import * as tui from '@/tui';
+import * as tui from '../../tui';
 
 export const deleteCommand = createSubcommand({
 	name: 'delete',

package/src/cmd/profile/index.ts

@@ -1,4 +1,4 @@
-import { createCommand } from '@/types';
+import { createCommand } from '../../types';
 import { createCommand as createProfileCmd } from './create';
 import { useCommand } from './use';
 import { listCommand } from './list';

package/src/cmd/profile/list.ts

@@ -1,7 +1,7 @@
-import type { SubcommandDefinition } from '@/types';
-import { fetchProfiles } from '@/config';
+import type { SubcommandDefinition } from '../../types';
+import { fetchProfiles } from '../../config';
 import { basename, dirname } from 'node:path';
-import * as tui from '@/tui';
+import * as tui from '../../tui';
 
 export const listCommand: SubcommandDefinition = {
 	name: 'list',

package/src/cmd/profile/show.ts

@@ -1,8 +1,8 @@
-import { createSubcommand } from '@/types';
+import { createSubcommand } from '../../types';
 import { z } from 'zod';
-import { getProfile, fetchProfiles } from '@/config';
+import { getProfile, fetchProfiles } from '../../config';
 import { readFile } from 'node:fs/promises';
-import * as tui from '@/tui';
+import * as tui from '../../tui';
 
 export const showCommand = createSubcommand({
 	name: 'show',

package/src/cmd/profile/use.ts

@@ -1,7 +1,7 @@
-import { createSubcommand } from '@/types';
+import { createSubcommand } from '../../types';
 import { z } from 'zod';
-import { fetchProfiles, saveProfile } from '@/config';
-import * as tui from '@/tui';
+import { fetchProfiles, saveProfile } from '../../config';
+import * as tui from '../../tui';
 
 export const useCommand = createSubcommand({
 	name: 'use',

package/src/cmd/project/create.ts

@@ -1,4 +1,4 @@
-import { createSubcommand } from '@/types';
+import { createSubcommand } from '../../types';
 import { z } from 'zod';
 import { runCreateFlow } from './template-flow';
 

package/src/cmd/project/delete.ts

@@ -1,4 +1,4 @@
-import { createSubcommand } from '@/types';
+import { createSubcommand } from '../../types';
 
 export const deleteSubcommand = createSubcommand({
 	name: 'delete',

package/src/cmd/project/download.ts

@@ -4,9 +4,9 @@ import { homedir } from 'node:os';
 import { pipeline } from 'node:stream/promises';
 import { createGunzip } from 'node:zlib';
 import { extract, type Headers } from 'tar-fs';
-import type { Logger } from '@/logger';
-import * as tui from '@/tui';
-import { downloadWithSpinner } from '@/download';
+import type { Logger } from '../../logger';
+import * as tui from '../../tui';
+import { downloadWithSpinner } from '../../download';
 import type { TemplateInfo } from './templates';
 
 const GITHUB_REPO = 'agentuity/sdk';

package/src/cmd/project/index.ts

@@ -1,4 +1,4 @@
-import { createCommand } from '@/types';
+import { createCommand } from '../../types';
 import { createProjectSubcommand } from './create';
 import { listSubcommand } from './list';
 import { deleteSubcommand } from './delete';

package/src/cmd/project/list.ts

@@ -1,4 +1,4 @@
-import { createSubcommand } from '@/types';
+import { createSubcommand } from '../../types';
 
 export const listSubcommand = createSubcommand({
 	name: 'list',

package/src/cmd/project/show.ts

@@ -1,4 +1,4 @@
-import { createSubcommand } from '@/types';
+import { createSubcommand } from '../../types';
 
 export const showSubcommand = createSubcommand({
 	name: 'show',

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

@@ -3,9 +3,9 @@ import { existsSync, readdirSync, rmSync } from 'node:fs';
 import { cwd } from 'node:process';
 import { homedir } from 'node:os';
 import enquirer from 'enquirer';
-import type { Logger } from '@/logger';
-import * as tui from '@/tui';
-import { playSound } from '@/sound';
+import type { Logger } from '../../logger';
+import * as tui from '../../tui';
+import { playSound } from '../../sound';
 import { fetchTemplates, type TemplateInfo } from './templates';
 import { downloadTemplate, setupProject } from './download';
 

package/src/cmd/version/index.ts

@@ -1,6 +1,6 @@
-import { createCommand } from '@/types';
-import { getVersion } from '@/version';
-import { logger } from '@/logger';
+import { createCommand } from '../../types';
+import { getVersion } from '../../version';
+import { logger } from '../../logger';
 
 export const command = createCommand({
 	name: 'version',

package/src/config.ts

@@ -1,10 +1,10 @@
 import { YAML } from 'bun';
-import { join, extname } from 'node:path';
+import { join, extname, basename } from 'node:path';
 import { homedir } from 'node:os';
 import { mkdir, readdir, readFile, writeFile, chmod } from 'node:fs/promises';
 import type { Config, Profile, AuthData } from './types';
 import { ConfigSchema } from './types';
-import * as tui from '@/tui';
+import * as tui from './tui';
 import { z } from 'zod';
 
 export function getDefaultConfigDir(): string {
@@ -104,6 +104,13 @@ export async function loadConfig(customPath?: string): Promise<Config | null> {
 		const content = await file.text();
 		const config = YAML.parse(content);
 
+		// check to see if this is a legacy config file that might not have the required name
+		// and in this case we can just use the filename
+		const _config = config as { name?: string };
+		if (!_config.name) {
+			_config.name = basename(configPath).replace(extname(configPath), '');
+		}
+
 		const result = ConfigSchema.safeParse(config);
 		if (!result.success) {
 			tui.error(`Invalid config in ${configPath}:`);

package/src/index.ts

@@ -1,6 +1,7 @@
 export { createCLI, registerCommands } from './cli';
 export { validateRuntime, isBun } from './runtime';
 export { getVersion, getRevision, getPackageName, getPackage } from './version';
+export { requireAuth, optionalAuth, withAuth, withOptionalAuth } from './auth';
 export {
 	loadConfig,
 	saveConfig,