@agentuity/cli 2.0.5 → 2.0.7

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

@@ -5,11 +5,132 @@
  */
 
 import { join } from 'node:path';
-import { existsSync, rmSync } from 'node:fs';
+import { existsSync, rmSync, mkdirSync, writeFileSync, readFileSync } from 'node:fs';
+import { createHash } from 'node:crypto';
+import { createRequire } from 'node:module';
 import type { InlineConfig } from 'vite';
 import type { Logger, DeployOptions } from '../../../types';
 import type { BuildReportCollector } from '../../../build-report';
 
+/**
+ * Read the pre-built beacon script from @agentuity/frontend package.
+ * Tries multiple resolution strategies for workspace/installed/symlink scenarios.
+ */
+async function readBeaconScript(projectRoot: string): Promise<string> {
+	let frontendPath: string | null = null;
+
+	try {
+		frontendPath = await Bun.resolve('@agentuity/frontend', projectRoot);
+	} catch {
+		// Not found from project root
+	}
+
+	if (!frontendPath) {
+		try {
+			const thisDir = new URL('.', import.meta.url).pathname;
+			frontendPath = await Bun.resolve('@agentuity/frontend', thisDir);
+		} catch {
+			// Not found from CLI directory
+		}
+	}
+
+	if (!frontendPath) {
+		try {
+			const projectRequire = createRequire(join(projectRoot, 'package.json'));
+			frontendPath = projectRequire.resolve('@agentuity/frontend');
+		} catch {
+			// Not found via createRequire
+		}
+	}
+
+	if (!frontendPath) {
+		throw new Error(
+			'Could not resolve @agentuity/frontend. Ensure the package is installed and built.'
+		);
+	}
+
+	const packageDir = join(frontendPath, '..');
+	const beaconPath = join(packageDir, 'beacon.js');
+
+	const beaconFile = Bun.file(beaconPath);
+	if (!(await beaconFile.exists())) {
+		throw new Error(
+			`Beacon script not found at ${beaconPath}. Run "bun run build" in @agentuity/frontend first.`
+		);
+	}
+
+	return beaconFile.text();
+}
+
+/**
+ * Post-build step: inject the analytics beacon into the built index.html.
+ *
+ * 1. Reads the beacon script from @agentuity/frontend
+ * 2. Writes it as a content-hashed asset file
+ * 3. Injects a <script data-agentuity-beacon> tag into the HTML
+ *
+ * This runs after `vite build` completes so it works regardless of the
+ * user's vite.config.ts — no Vite plugin required.
+ */
+async function injectBeacon(rootDir: string, cdnBaseUrl: string, logger: Logger): Promise<void> {
+	const clientDir = join(rootDir, '.agentuity/client');
+	const indexHtmlPath = join(clientDir, 'index.html');
+
+	if (!existsSync(indexHtmlPath)) {
+		logger.debug('No index.html found, skipping beacon injection');
+		return;
+	}
+
+	let beaconCode: string;
+	try {
+		beaconCode = await readBeaconScript(rootDir);
+	} catch (error) {
+		logger.warn(
+			'Failed to read beacon script, skipping injection: %s',
+			error instanceof Error ? error.message : String(error)
+		);
+		return;
+	}
+
+	// Write beacon as a content-hashed asset (matches Vite's naming convention)
+	const hash = createHash('sha256').update(beaconCode).digest('hex').slice(0, 8);
+	const beaconFileName = `agentuity-beacon-${hash}.js`;
+	const assetsDir = join(clientDir, 'assets');
+	mkdirSync(assetsDir, { recursive: true });
+	writeFileSync(join(assetsDir, beaconFileName), beaconCode);
+
+	// If a Vite manifest exists, add the beacon so the metadata generator
+	// includes it in the asset list. When no manifest exists, the directory
+	// scanner in metadata-generator.ts picks up assets/ directly.
+	const manifestPath = join(clientDir, '.vite', 'manifest.json');
+	if (existsSync(manifestPath)) {
+		const manifest = JSON.parse(readFileSync(manifestPath, 'utf-8'));
+		manifest['agentuity-beacon'] = { file: `assets/${beaconFileName}` };
+		writeFileSync(manifestPath, JSON.stringify(manifest));
+	}
+
+	// Build the beacon URL using the CDN base
+	const normalizedBase = cdnBaseUrl.endsWith('/') ? cdnBaseUrl : `${cdnBaseUrl}/`;
+	const beaconUrl = `${normalizedBase}assets/${beaconFileName}`;
+
+	// Inject the script tag into index.html
+	// The script must be sync (no async/defer) to patch history API before router loads.
+	// The data-agentuity-beacon attribute is the marker the runtime looks for.
+	const beaconScript = `<script data-agentuity-beacon src="${beaconUrl}"></script>`;
+
+	let html = readFileSync(indexHtmlPath, 'utf-8');
+	if (html.includes('</head>')) {
+		html = html.replace('</head>', `${beaconScript}</head>`);
+	} else if (html.includes('<body')) {
+		html = html.replace(/<body([^>]*)>/, `<body$1>${beaconScript}`);
+	} else {
+		html = beaconScript + html;
+	}
+
+	writeFileSync(indexHtmlPath, html);
+	logger.debug('Injected analytics beacon: %s', beaconUrl);
+}
+
 export interface ViteBuildOptions {
 	rootDir: string;
 	mode: 'client' | 'server' | 'workbench';
@@ -116,18 +237,43 @@ export default defineConfig({
 			await Bun.write(viteConfigPath, fallbackConfig);
 		}
 
+		// Construct CDN base URL for production builds so Vite prefixes all
+		// asset URLs (CSS, JS chunks) with the CDN origin instead of "/".
+		const cdnBaseUrl =
+			!dev && options.deploymentId
+				? `https://${options.region === 'local' ? 'localstack-static-assets.t3.storageapi.dev' : 'cdn.agentuity.com'}/${options.deploymentId}/client/`
+				: undefined;
+
+		const args = [
+			'bun',
+			'x',
+			'vite',
+			'build',
+			'--mode',
+			buildMode,
+			'--outDir',
+			clientOutDir,
+			'--logLevel',
+			'error',
+			'--clearScreen',
+			'false',
+		];
+		if (cdnBaseUrl) {
+			args.push('--base', cdnBaseUrl);
+		}
+
 		logger.debug('Spawning vite build for client (subprocess mode)');
 		logger.debug('  outDir: %s', clientOutDir);
 		logger.debug('  mode: %s', buildMode);
+		if (cdnBaseUrl) {
+			logger.debug('  base (CDN): %s', cdnBaseUrl);
+		}
 
-		const viteProcess = Bun.spawn(
-			['bun', 'x', 'vite', 'build', '--mode', buildMode, '--outDir', clientOutDir],
-			{
-				cwd: rootDir,
-				stdout: 'inherit',
-				stderr: 'inherit',
-			}
-		);
+		const viteProcess = Bun.spawn(args, {
+			cwd: rootDir,
+			stdout: 'inherit',
+			stderr: 'inherit',
+		});
 
 		const exitCode = await viteProcess.exited;
 
@@ -264,6 +410,22 @@ export async function runAllBuilds(options: Omit<ViteBuildOptions, 'mode'>): Pro
 			logger.debug('Moved index.html from src/web/ to client root');
 		}
 
+		// Post-build: inject analytics beacon into the built HTML.
+		// Must run AFTER the index.html normalization above (Vite may
+		// output to src/web/index.html which gets moved to the client root).
+		const isLocalRegion = options.region === 'local';
+		const cdnDomain = isLocalRegion
+			? 'localstack-static-assets.t3.storageapi.dev'
+			: 'cdn.agentuity.com';
+		const cdnBaseUrl =
+			!dev && options.deploymentId
+				? `https://${cdnDomain}/${options.deploymentId}/client/`
+				: undefined;
+
+		if (cdnBaseUrl && analyticsEnabled) {
+			await injectBeacon(rootDir, cdnBaseUrl, logger);
+		}
+
 		result.client.included = true;
 		result.client.duration = Date.now() - started;
 		endClientDiagnostic?.();

package/src/cmd/cloud/task/close.ts

@@ -0,0 +1,319 @@
+import { z } from 'zod';
+import { createCommand } from '../../../types';
+import * as tui from '../../../tui';
+import { createStorageAdapter, resolveMeId, parseDuration, truncate } from './util';
+import { getCommand } from '../../../command-prefix';
+import { isDryRunMode, outputDryRun } from '../../../explain';
+import type { TaskPriority, TaskStatus, TaskType, BatchClosedTask } from '@agentuity/core';
+
+const TaskCloseResponseSchema = z.object({
+	success: z.boolean().describe('Whether the operation succeeded'),
+	closed: z
+		.array(
+			z.object({
+				id: z.string().describe('Closed task ID'),
+				title: z.string().describe('Closed task title'),
+				status: z.string().describe('Task status'),
+				closed_date: z.string().optional().describe('ISO 8601 closed date'),
+			})
+		)
+		.describe('List of closed tasks'),
+	count: z.number().describe('Number of tasks closed'),
+	durationMs: z.number().describe('Operation duration in milliseconds'),
+	dryRun: z.boolean().optional().describe('Whether this was a dry run'),
+	message: z.string().optional().describe('Status message'),
+});
+
+export const closeSubcommand = createCommand({
+	name: 'close',
+	aliases: ['done', 'complete'],
+	description: 'Close a task by ID or batch-close tasks by filter',
+	tags: ['mutating', 'slow', 'requires-auth'],
+	requires: { auth: true },
+	examples: [
+		{
+			command: getCommand('cloud task close task_abc123'),
+			description: 'Close a single task by ID',
+		},
+		{
+			command: getCommand('cloud task close --status in_progress --older-than 7d'),
+			description: 'Close in-progress tasks older than 7 days',
+		},
+		{
+			command: getCommand('cloud task close --status open --limit 10 --dry-run'),
+			description: 'Preview which open tasks would be closed (dry run)',
+		},
+		{
+			command: getCommand('cloud task close --created-id me --confirm'),
+			description: 'Close all tasks created by me without confirmation prompt',
+		},
+	],
+	schema: {
+		args: z.object({
+			id: z.string().optional().describe('Task ID to close (for single close)'),
+		}),
+		options: z.object({
+			status: z
+				.enum(['open', 'in_progress', 'started', 'done', 'completed', 'closed', 'cancelled'])
+				.optional()
+				.describe('filter batch close by status'),
+			type: z
+				.enum(['epic', 'feature', 'enhancement', 'bug', 'task'])
+				.optional()
+				.describe('filter batch close by type'),
+			priority: z
+				.enum(['high', 'medium', 'low', 'none'])
+				.optional()
+				.describe('filter batch close by priority'),
+			olderThan: z
+				.string()
+				.optional()
+				.describe('filter batch close by age (e.g. 30s, 7d, 24h, 2w)'),
+			parentId: z.string().optional().describe('filter batch close by parent task ID'),
+			createdId: z
+				.string()
+				.optional()
+				.describe('filter batch close by creator ID (use "me" for current user)'),
+			assignedId: z.string().optional().describe('filter batch close by assigned user ID'),
+			projectId: z.string().optional().describe('filter batch close by project ID'),
+			tagId: z.string().optional().describe('filter batch close by tag ID'),
+			idsFile: z.string().optional().describe('path to JSON file containing task IDs to close'),
+			orgId: z.string().optional().describe('organization ID (uses default if not specified)'),
+			dryRun: z
+				.boolean()
+				.optional()
+				.default(false)
+				.describe('preview changes without executing'),
+			limit: z.coerce
+				.number()
+				.int()
+				.min(1)
+				.max(200)
+				.default(50)
+				.describe('max tasks to close in batch mode (default: 50, max: 200)'),
+			confirm: z.boolean().optional().default(false).describe('skip confirmation prompt'),
+		}),
+		response: TaskCloseResponseSchema,
+	},
+
+	async handler(ctx) {
+		const { args, opts, options } = ctx;
+		const started = Date.now();
+		const storage = await createStorageAdapter(ctx);
+
+		const isSingleClose = !!args.id;
+		const hasFilters =
+			opts.status ||
+			opts.type ||
+			opts.priority ||
+			opts.olderThan ||
+			opts.parentId ||
+			opts.createdId ||
+			opts.assignedId ||
+			opts.projectId ||
+			opts.tagId ||
+			opts.idsFile;
+
+		if (!isSingleClose && !hasFilters) {
+			tui.fatal(
+				'Provide a task ID for single close, or use --status, --type, --priority, --older-than, --parent-id, --created-id, --assigned-id, --project-id, --tag-id, or --ids-file for batch close.'
+			);
+		}
+
+		if (isSingleClose && hasFilters) {
+			tui.fatal(
+				'Cannot combine task ID with filter options. Use either single close (by ID) or batch close (by filters).'
+			);
+		}
+
+		if (isSingleClose) {
+			if (isDryRunMode(options)) {
+				outputDryRun(`Would close task: ${args.id}`, options);
+				return {
+					success: true,
+					closed: [{ id: args.id!, title: '(dry run)', status: 'done' }],
+					count: 1,
+					durationMs: Date.now() - started,
+					dryRun: true,
+					message: 'Dry run — no tasks were closed',
+				};
+			}
+
+			if (!opts.confirm) {
+				const confirmed = await tui.confirm(`Close task "${args.id}"?`, false);
+				if (!confirmed) {
+					if (!options.json) tui.info('Cancelled');
+					return {
+						success: false,
+						closed: [],
+						count: 0,
+						durationMs: Date.now() - started,
+						message: 'Cancelled',
+					};
+				}
+			}
+
+			const task = await storage.close(args.id!);
+			const durationMs = Date.now() - started;
+
+			if (!options.json) {
+				tui.success(`Closed task ${tui.bold(task.id)} (${task.title}) in ${durationMs}ms`);
+			}
+
+			return {
+				success: true,
+				closed: [
+					{
+						id: task.id,
+						title: task.title,
+						status: task.status,
+						closed_date: task.closed_date,
+					},
+				],
+				count: 1,
+				durationMs,
+			};
+		}
+
+		// Batch close mode
+		if (opts.olderThan) {
+			parseDuration(opts.olderThan);
+		}
+
+		const createdId = resolveMeId(opts.createdId, ctx);
+		const assignedId = resolveMeId(opts.assignedId, ctx);
+
+		// Handle IDs file
+		let explicitIds: string[] | undefined;
+		if (opts.idsFile) {
+			const file = Bun.file(opts.idsFile);
+			if (!(await file.exists())) {
+				tui.fatal(`IDs file not found: ${opts.idsFile}`);
+			}
+			try {
+				const content = await file.json();
+				if (Array.isArray(content)) {
+					explicitIds = content.map((id) => String(id));
+				} else if (content && Array.isArray((content as { ids?: string[] }).ids)) {
+					explicitIds = (content as { ids: string[] }).ids;
+				} else {
+					tui.fatal(`Invalid IDs file format. Expected array of IDs or { ids: [...] }`);
+				}
+			} catch (err) {
+				tui.fatal(`Failed to parse IDs file: ${err}`);
+			}
+		}
+
+		const batchParams = {
+			status: opts.status as TaskStatus | undefined,
+			type: opts.type as TaskType | undefined,
+			priority: opts.priority as TaskPriority | undefined,
+			parent_id: opts.parentId,
+			created_id: createdId,
+			assigned_id: assignedId,
+			project_id: opts.projectId,
+			tag_id: opts.tagId,
+			older_than: opts.olderThan,
+			ids: explicitIds,
+			limit: opts.limit,
+			closed_id: ctx.auth.userId,
+			dry_run: isDryRunMode(options),
+		};
+
+		// For confirmation, run a dry-run first to preview
+		if (!isDryRunMode(options) && !opts.confirm) {
+			const preview = await storage.batchClose({ ...batchParams, dry_run: true });
+
+			if (preview.count === 0) {
+				if (!options.json) tui.info('No tasks match the given filters');
+				return {
+					success: true,
+					closed: [],
+					count: 0,
+					durationMs: Date.now() - started,
+					message: 'No matching tasks found',
+				};
+			}
+
+			if (!options.json) {
+				tui.warning(
+					`Found ${preview.count} ${tui.plural(preview.count, 'task', 'tasks')} to close:`
+				);
+				tui.newline();
+
+				const tableData = preview.closed.map((task: BatchClosedTask) => ({
+					ID: tui.muted(truncate(task.id, 28)),
+					Title: truncate(task.title, 40),
+					Status: task.status,
+				}));
+
+				tui.table(tableData, [
+					{ name: 'ID', alignment: 'left' },
+					{ name: 'Title', alignment: 'left' },
+					{ name: 'Status', alignment: 'left' },
+				]);
+				tui.newline();
+			}
+
+			const confirmed = await tui.confirm(
+				`Close ${preview.count} ${tui.plural(preview.count, 'task', 'tasks')}?`,
+				false
+			);
+			if (!confirmed) {
+				if (!options.json) tui.info('Cancelled');
+				return {
+					success: false,
+					closed: [],
+					count: 0,
+					durationMs: Date.now() - started,
+					message: 'Cancelled',
+				};
+			}
+		}
+
+		// Execute batch close
+		const result = await storage.batchClose(batchParams);
+		const durationMs = Date.now() - started;
+
+		if (!options.json) {
+			if (result.dry_run) {
+				if (result.count > 0) {
+					tui.info(
+						`Dry run: would close ${result.count} ${tui.plural(result.count, 'task', 'tasks')}`
+					);
+				} else {
+					tui.info('No tasks match the given filters');
+				}
+			} else if (result.count > 0) {
+				tui.success(
+					`Closed ${result.count} ${tui.plural(result.count, 'task', 'tasks')} in ${durationMs}ms`
+				);
+
+				// Show which tasks were closed
+				if (result.closed.length > 0) {
+					tui.newline();
+					const closedTable = result.closed.map((task) => ({
+						ID: tui.muted(truncate(task.id, 28)),
+						Title: truncate(task.title, 40),
+					}));
+					tui.table(closedTable, [
+						{ name: 'ID', alignment: 'left' },
+						{ name: 'Title', alignment: 'left' },
+					]);
+				}
+			} else {
+				tui.info('No tasks matched the given filters');
+			}
+		}
+
+		return {
+			success: true,
+			closed: result.closed,
+			count: result.count,
+			durationMs,
+			dryRun: result.dry_run,
+		};
+	},
+});
+
+export default closeSubcommand;

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

@@ -1,46 +1,13 @@
 import { z } from 'zod';
 import { createCommand } from '../../../types';
 import * as tui from '../../../tui';
-import { createStorageAdapter } from './util';
+import { createStorageAdapter, resolveMeId, parseDuration, truncate } from './util';
 import { getCommand } from '../../../command-prefix';
 import { isDryRunMode, outputDryRun } from '../../../explain';
 import type { TaskPriority, TaskStatus, TaskType, BatchDeletedTask } from '@agentuity/core';
 
-const DURATION_UNITS: Record<string, number> = {
-	s: 1000,
-	m: 60 * 1000,
-	h: 60 * 60 * 1000,
-	d: 24 * 60 * 60 * 1000,
-	w: 7 * 24 * 60 * 60 * 1000,
-};
-
-/**
- * Parse a human-friendly duration string (e.g. "30s", "7d", "24h", "30m", "2w")
- * into milliseconds. Exported for testing.
- */
-export function parseDuration(duration: string): number {
-	const match = duration.match(/^(\d+)([smhdw])$/);
-	if (!match) {
-		tui.fatal(
-			`Invalid duration format: "${duration}". Use a number followed by s (seconds), m (minutes), h (hours), d (days), or w (weeks). Examples: 30s, 30m, 24h, 7d, 2w`
-		);
-		// tui.fatal exits, but TypeScript doesn't know that
-		throw new Error('unreachable');
-	}
-	const value = parseInt(match[1]!, 10);
-	const unit = match[2]!;
-	const ms = DURATION_UNITS[unit];
-	if (!ms) {
-		tui.fatal(`Unknown duration unit: "${unit}"`);
-		throw new Error('unreachable');
-	}
-	return value * ms;
-}
-
-function truncate(s: string, max: number): string {
-	if (s.length <= max) return s;
-	return `${s.slice(0, max - 1)}…`;
-}
+// Re-export for testing
+export { parseDuration } from './util';
 
 const TaskDeleteResponseSchema = z.object({
 	success: z.boolean().describe('Whether the operation succeeded'),
@@ -104,7 +71,16 @@ export const deleteSubcommand = createCommand({
 				.optional()
 				.describe('filter batch delete by age (e.g. 30s, 7d, 24h, 2w)'),
 			parentId: z.string().optional().describe('filter batch delete by parent task ID'),
-			createdId: z.string().optional().describe('filter batch delete by creator ID'),
+			createdId: z
+				.string()
+				.optional()
+				.describe('filter batch delete by creator ID (use "me" for current user)'),
+			orgId: z.string().optional().describe('organization ID (uses default if not specified)'),
+			dryRun: z
+				.boolean()
+				.optional()
+				.default(false)
+				.describe('preview changes without executing'),
 			limit: z.coerce
 				.number()
 				.int()
@@ -198,7 +174,7 @@ export const deleteSubcommand = createCommand({
 			type: opts.type as TaskType | undefined,
 			priority: opts.priority as TaskPriority | undefined,
 			parent_id: opts.parentId,
-			created_id: opts.createdId,
+			created_id: resolveMeId(opts.createdId, ctx),
 			older_than: opts.olderThan,
 			limit: opts.limit,
 		};
@@ -212,6 +188,7 @@ export const deleteSubcommand = createCommand({
 				type: batchParams.type,
 				priority: batchParams.priority,
 				parent_id: batchParams.parent_id,
+				created_id: batchParams.created_id,
 				limit: batchParams.limit,
 				sort: 'created_at',
 				order: 'asc',
@@ -219,11 +196,6 @@ export const deleteSubcommand = createCommand({
 
 			// Client-side filters for preview (server will apply these on actual delete)
 			let candidates = preview.tasks;
-			if (batchParams.created_id) {
-				candidates = candidates.filter(
-					(t: { created_id: string }) => t.created_id === batchParams.created_id
-				);
-			}
 			if (opts.olderThan) {
 				const durationMs = parseDuration(opts.olderThan);
 				const cutoff = new Date(Date.now() - durationMs);

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

@@ -4,6 +4,7 @@ import { createSubcommand } from './create';
 import { updateSubcommand } from './update';
 import { listSubcommand } from './list';
 import { deleteSubcommand } from './delete';
+import { closeSubcommand } from './close';
 import { statsSubcommand } from './stats';
 import { attachmentSubcommand } from './attachment';
 import { userSubcommand } from './user';
@@ -36,6 +37,14 @@ export const taskCommand = createCommand({
 			command: getCommand('cloud task delete task_abc123'),
 			description: 'Delete a task by ID',
 		},
+		{
+			command: getCommand('cloud task close task_abc123'),
+			description: 'Close a task by ID',
+		},
+		{
+			command: getCommand('cloud task close --status done --older-than 7d'),
+			description: 'Batch close done tasks older than 7 days',
+		},
 		{
 			command: getCommand('cloud task delete --status done --older-than 7d'),
 			description: 'Batch delete done tasks older than 7 days',
@@ -59,6 +68,7 @@ export const taskCommand = createCommand({
 		updateSubcommand,
 		listSubcommand,
 		deleteSubcommand,
+		closeSubcommand,
 		statsSubcommand,
 		attachmentSubcommand,
 		userSubcommand,