@agentuity/cli 2.0.11 → 2.0.13

package/src/cmd/dev/process-manager.ts

@@ -7,6 +7,14 @@
  * - Graceful shutdown (SIGINT/SIGTERM)
  *
  * This prevents orphan processes and port conflicts between dev sessions.
+ *
+ * Key design decisions:
+ * - Process tree killing: Uses process.kill(-pid) to kill entire process groups,
+ *   preventing orphaned child processes (e.g., Bun backend spawning workers).
+ * - Per-process SIGTERM→SIGKILL escalation: Each process gets its own grace
+ *   period instead of waiting for all processes to exit before force-killing.
+ * - Last-resort synchronous cleanup: forceKillAllSync() can be called from
+ *   process.on('exit') handlers where async operations are not possible.
  */
 
 import type { Logger } from '../../types';
@@ -39,6 +47,12 @@ export interface ManagedServer {
 	description: string;
 	/** The port this server uses */
 	port?: number;
+	/**
+	 * Maximum time (ms) to wait for this server's close() to resolve before
+	 * moving on. Defaults to 1000ms. Servers like Vite that own filesystem
+	 * watchers and HMR sockets may need more time.
+	 */
+	closeTimeoutMs?: number;
 }
 
 /**
@@ -114,11 +128,71 @@ export class ProcessManager {
 		return ports;
 	}
 
+	/**
+	 * Whether cleanup has already completed.
+	 * Used by forceKillAllSync() to avoid redundant work.
+	 */
+	get isCleanedUp(): boolean {
+		return this.cleaningUp && this.processes.length === 0 && this.servers.length === 0;
+	}
+
+	/**
+	 * Kill a process and its entire process tree.
+	 *
+	 * Uses process.kill(-pid) to send the signal to the entire process group.
+	 * This ensures child processes (e.g., workers spawned by Bun) are also killed.
+	 * Falls back to direct PID kill if process group kill fails (e.g., EPERM or
+	 * the process is not a group leader).
+	 */
+	private killProcessTree(pid: number, signal: NodeJS.Signals): boolean {
+		// Safety: never send signals to PID 0 (own process group), PID 1 (init/systemd),
+		// or negative PIDs (which would be double-negated). process.kill(-1) is
+		// especially dangerous as it signals every process the user owns.
+		if (pid <= 1) {
+			this.logger.debug('Refusing to kill dangerous pid %d, skipping process tree kill', pid);
+			return false;
+		}
+
+		// Try killing the entire process group first (negative PID)
+		try {
+			process.kill(-pid, signal);
+			this.logger.debug('Sent %s to process group -%d', signal, pid);
+			return true;
+		} catch (err) {
+			const error = err as NodeJS.ErrnoException;
+			// ESRCH = no such process/group, EPERM = not a group leader or no permission
+			if (error.code !== 'ESRCH') {
+				this.logger.debug(
+					'Process group kill failed for pid %d (%s), falling back to direct kill',
+					pid,
+					error.code
+				);
+			}
+		}
+
+		// Fall back to direct PID kill
+		try {
+			process.kill(pid, signal);
+			this.logger.debug('Sent %s to pid %d (direct)', signal, pid);
+			return true;
+		} catch (err) {
+			const error = err as NodeJS.ErrnoException;
+			if (error.code !== 'ESRCH') {
+				this.logger.debug('Direct kill failed for pid %d: %s', pid, error.code);
+			}
+			return false;
+		}
+	}
+
 	/**
 	 * Clean up all tracked processes and servers.
 	 *
+	 * Uses per-process SIGTERM→SIGKILL escalation: each process gets up to
+	 * `timeout` ms to exit gracefully after SIGTERM. Processes that exit early
+	 * don't delay cleanup of other processes.
+	 *
 	 * @param reason - Why cleanup is happening (for logging)
-	 * @param timeout - Max time to wait for graceful shutdown (ms)
+	 * @param timeout - Max time to wait for graceful shutdown per process (ms)
 	 */
 	async cleanup(reason: string, timeout = 3000): Promise<void> {
 		if (this.cleaningUp) {
@@ -129,61 +203,94 @@ export class ProcessManager {
 
 		this.logger.debug('Starting cleanup (reason: %s)', reason);
 
-		// Kill processes in reverse order (LIFO)
-		for (let i = this.processes.length - 1; i >= 0; i--) {
-			const proc = this.processes[i];
-			if (!proc) continue;
-
-			try {
-				if (proc.process.exitCode === null) {
-					this.logger.debug(
-						'Killing process %s (pid=%s)',
-						proc.id,
-						proc.process.pid ?? 'unknown'
-					);
-					proc.process.kill('SIGTERM');
-				}
-			} catch (err) {
-				this.logger.debug('Error killing process %s: %s', proc.id, err);
-			}
-		}
+		// Snapshot processes and servers before cleanup so we can clear tracking
+		// lists early. This prevents the exit handler from re-killing already
+		// handled processes.
+		const processSnapshot = [...this.processes];
+		const serverSnapshot = [...this.servers];
 
-		// Close servers
-		for (let i = this.servers.length - 1; i >= 0; i--) {
-			const server = this.servers[i];
+		// Close servers first (reverse order, LIFO)
+		for (let i = serverSnapshot.length - 1; i >= 0; i--) {
+			const server = serverSnapshot[i];
 			if (!server) continue;
 
+			const closeTimeout = server.closeTimeoutMs ?? 1000;
 			try {
-				this.logger.debug('Closing server %s', server.id);
+				this.logger.debug('Closing server %s (timeout=%dms)', server.id, closeTimeout);
 				const closePromise = server.server.close();
 				if (closePromise instanceof Promise) {
+					let timedOut = false;
 					await Promise.race([
 						closePromise,
-						new Promise<void>((resolve) => setTimeout(resolve, 1000)),
+						new Promise<void>((resolve) =>
+							setTimeout(() => {
+								timedOut = true;
+								resolve();
+							}, closeTimeout)
+						),
 					]);
+					if (timedOut) {
+						this.logger.debug(
+							'Server %s did not close within %dms, continuing cleanup',
+							server.id,
+							closeTimeout
+						);
+					}
 				}
 			} catch (err) {
 				this.logger.debug('Error closing server %s: %s', server.id, err);
 			}
 		}
 
-		// Wait for processes to exit, then force-kill if needed
+		// Send SIGTERM to all processes in reverse order (LIFO), targeting
+		// process trees so child processes also receive the signal.
+		for (let i = processSnapshot.length - 1; i >= 0; i--) {
+			const proc = processSnapshot[i];
+			if (!proc) continue;
+
+			try {
+				if (proc.process.exitCode === null) {
+					const pid = proc.process.pid;
+					this.logger.debug('Killing process %s (pid=%s)', proc.id, pid ?? 'unknown');
+					if (pid) {
+						this.killProcessTree(pid, 'SIGTERM');
+					} else {
+						proc.process.kill('SIGTERM');
+					}
+				}
+			} catch (err) {
+				this.logger.debug('Error killing process %s: %s', proc.id, err);
+			}
+		}
+
+		// Wait for processes to exit, then force-kill individually.
+		// Each process gets up to `timeout` ms from the initial SIGTERM.
 		const startTime = Date.now();
 		while (Date.now() - startTime < timeout) {
-			const allExited = this.processes.every((p) => p.process.exitCode !== null);
+			const allExited = processSnapshot.every((p) => p.process.exitCode !== null);
 			if (allExited) break;
 			await new Promise((resolve) => setTimeout(resolve, 100));
 		}
 
-		// Force kill any remaining
-		for (const proc of this.processes) {
-			if (proc.process.exitCode === null) {
-				try {
-					this.logger.debug('Force killing process %s', proc.id);
+		// Force kill any remaining processes and their process trees.
+		// When a PID is available, always attempt process-group SIGKILL even if
+		// the leader has already exited: on Unix, process groups persist after
+		// the leader exits and signaling via negative PGID still reaches
+		// remaining members. killProcessTree() handles ESRCH gracefully.
+		for (const proc of processSnapshot) {
+			const pid = proc.process.pid;
+			const shouldForceTreeKill = typeof pid === 'number' && pid > 1;
+			if (!shouldForceTreeKill && proc.process.exitCode !== null) continue;
+
+			try {
+				this.logger.debug('Force killing process %s (pid=%s)', proc.id, pid ?? 'unknown');
+				if (shouldForceTreeKill) {
+					this.killProcessTree(pid, 'SIGKILL');
+				} else {
 					proc.process.kill('SIGKILL');
-				} catch (err) {
-					this.logger.debug('Error force killing process %s: %s', proc.id, err);
 				}
+			} catch (err) {
+				this.logger.debug('Error force killing process %s: %s', proc.id, err);
 			}
 		}
 
@@ -192,6 +299,39 @@ export class ProcessManager {
 		this.servers = [];
 	}
 
+	/**
+	 * Synchronous last-resort cleanup for use in process.on('exit') handlers.
+	 *
+	 * Sends SIGKILL to all tracked process trees. This is intentionally
+	 * aggressive because it's the final opportunity to prevent orphans.
+	 * Only runs if async cleanup() hasn't already completed.
+	 */
+	forceKillAllSync(): void {
+		if (this.isCleanedUp) return;
+
+		for (const proc of this.processes) {
+			if (proc.process.exitCode !== null) continue;
+			const pid = proc.process.pid;
+			try {
+				if (pid && pid > 1) {
+					// Try process group kill first, fall back to direct
+					try {
+						process.kill(-pid, 'SIGKILL');
+					} catch {
+						process.kill(pid, 'SIGKILL');
+					}
+				} else {
+					proc.process.kill('SIGKILL');
+				}
+			} catch {
+				// Best effort in exit handler — nothing else we can do
+			}
+		}
+
+		this.processes = [];
+		this.servers = [];
+	}
+
 	/**
 	 * Verify that all ports used by tracked processes are released.
 	 * Used after cleanup to ensure no orphan processes remain.

package/src/cmd/project/create.ts

@@ -80,7 +80,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,
 	},
@@ -115,7 +114,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/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/random-name.ts

@@ -0,0 +1,152 @@
+/**
+ * Generates project-derived suggestions for resource names (DB / S3 bucket).
+ *
+ * The CLI shows these as a dim "press Enter to use ..." default in the create flow.
+ * If the user presses Enter, the suggestion is sent to the server. Otherwise the
+ * server is responsible for assigning a name when none is provided.
+ *
+ * Both suggestions are validated against the same rules the server enforces
+ * (`validateBucketName` / `validateDatabaseName` from `@agentuity/server`) so the
+ * happy path can never produce an invalid suggestion.
+ */
+import { validateBucketName, validateDatabaseName } from '@agentuity/server';
+
+const BUCKET_MAX = 63;
+const BUCKET_MIN = 3;
+const DB_MAX = 63;
+
+/** 3 lowercase alphanumeric chars, e.g. "k7p". */
+function shortSuffix(): string {
+	// toString(36) yields [0-9a-z]; slice 3 chars after the "0." prefix.
+	const s = Math.random().toString(36).slice(2, 5);
+	// Pad in the (extremely unlikely) case the slice is shorter than 3 chars.
+	return s.length === 3 ? s : (s + '000').slice(0, 3);
+}
+
+/**
+ * Sanitize a project name into the bucket-name alphabet:
+ * - lowercase
+ * - spaces / underscores / dots → hyphens
+ * - drop anything else
+ * - collapse and trim hyphens
+ * - strip reserved prefixes (`agentuity*`, `ag-*`, `ago-*`, `xn--`)
+ */
+function sanitizeForBucket(name: string): string {
+	let out = name
+		.toLowerCase()
+		.trim()
+		.replace(/[\s_.]+/g, '-')
+		.replace(/[^a-z0-9-]/g, '')
+		.replace(/-+/g, '-')
+		.replace(/^-+|-+$/g, '');
+
+	// Strip reserved prefixes (rules from validateBucketName).
+	while (
+		out.startsWith('agentuity') ||
+		out.startsWith('ag-') ||
+		out.startsWith('ago-') ||
+		out.startsWith('xn--')
+	) {
+		if (out.startsWith('agentuity')) out = out.slice('agentuity'.length);
+		else if (out.startsWith('ago-')) out = out.slice('ago-'.length);
+		else if (out.startsWith('ag-')) out = out.slice('ag-'.length);
+		else if (out.startsWith('xn--')) out = out.slice('xn--'.length);
+		out = out.replace(/^-+/, '');
+	}
+	return out;
+}
+
+/**
+ * Sanitize a project name into the database-name alphabet:
+ * - lowercase
+ * - non `[a-z0-9_]` → `_`
+ * - collapse and trim underscores
+ * - ensure it starts with a letter or underscore (prepend `p_` otherwise)
+ * - strip reserved `pg_` prefix
+ */
+function sanitizeForDatabase(name: string): string {
+	let out = name
+		.toLowerCase()
+		.trim()
+		.replace(/[^a-z0-9_]+/g, '_')
+		.replace(/_+/g, '_')
+		.replace(/^_+|_+$/g, '');
+
+	if (!/^[a-z_]/.test(out)) {
+		out = out.length > 0 ? `p_${out}` : '';
+	}
+	while (out.startsWith('pg_')) {
+		out = out.slice(3).replace(/^_+/, '');
+		if (!/^[a-z_]/.test(out) && out.length > 0) out = `p_${out}`;
+	}
+	return out;
+}
+
+/**
+ * Truncate so the final string (`<base>-<suffixWithDash>`) fits within `max` chars
+ * while keeping the suffix intact and not ending on a hyphen.
+ */
+function truncateBaseHyphen(base: string, suffixWithDash: string, max: number): string {
+	const room = max - suffixWithDash.length;
+	if (room <= 0) return '';
+	let out = base.slice(0, room);
+	out = out.replace(/-+$/, '');
+	return out;
+}
+
+/** Same as `truncateBaseHyphen` but for underscore-joined names (database). */
+function truncateBaseUnderscore(base: string, suffixWithUnderscore: string, max: number): string {
+	const room = max - suffixWithUnderscore.length;
+	if (room <= 0) return '';
+	let out = base.slice(0, room);
+	out = out.replace(/_+$/, '');
+	return out;
+}
+
+/**
+ * Generate a suggested S3 bucket name derived from the project name.
+ * Format: `<sanitized-project>-storage-<3char>` (≤ 63 chars).
+ *
+ * Falls back to `bucket-<3char><3char>` if the project name produces nothing usable.
+ * Always returns a value that passes `validateBucketName`.
+ */
+export function suggestBucketName(projectName: string): string {
+	const sanitized = sanitizeForBucket(projectName);
+
+	// Try a few times in case sanitization + suffix happens to land on something invalid.
+	for (let attempt = 0; attempt < 5; attempt++) {
+		const suffix = `-storage-${shortSuffix()}`;
+		const base = truncateBaseHyphen(sanitized, suffix, BUCKET_MAX);
+		const candidate = base.length > 0 ? `${base}${suffix}` : `bucket${suffix}`;
+		if (candidate.length >= BUCKET_MIN && validateBucketName(candidate).valid) {
+			return candidate;
+		}
+	}
+
+	// Pure fallback: short, always-valid generic name.
+	const fallback = `bucket-${shortSuffix()}${shortSuffix()}`;
+	return validateBucketName(fallback).valid ? fallback : `bucket-${shortSuffix()}aaa`;
+}
+
+/**
+ * Generate a suggested PostgreSQL database name derived from the project name.
+ * Format: `<sanitized-project>_db_<3char>` (≤ 63 chars).
+ *
+ * Falls back to `db_<3char><3char>` if the project name produces nothing usable.
+ * Always returns a value that passes `validateDatabaseName`.
+ */
+export function suggestDatabaseName(projectName: string): string {
+	const sanitized = sanitizeForDatabase(projectName);
+
+	for (let attempt = 0; attempt < 5; attempt++) {
+		const suffix = `_db_${shortSuffix()}`;
+		const base = truncateBaseUnderscore(sanitized, suffix, DB_MAX);
+		const candidate = base.length > 0 ? `${base}${suffix}` : `db${suffix}`;
+		if (validateDatabaseName(candidate).valid) {
+			return candidate;
+		}
+	}
+
+	const fallback = `db_${shortSuffix()}${shortSuffix()}`;
+	return validateDatabaseName(fallback).valid ? fallback : `db_${shortSuffix()}aaa`;
+}