@agentuity/cli 1.0.36 → 1.0.38

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@agentuity/cli",
-	"version": "1.0.36",
+	"version": "1.0.38",
 	"license": "Apache-2.0",
 	"author": "Agentuity employees and contributors",
 	"type": "module",
@@ -41,9 +41,9 @@
 		"prepublishOnly": "bun run clean && bun run build"
 	},
 	"dependencies": {
-		"@agentuity/auth": "1.0.36",
-		"@agentuity/core": "1.0.36",
-		"@agentuity/server": "1.0.36",
+		"@agentuity/auth": "1.0.38",
+		"@agentuity/core": "1.0.38",
+		"@agentuity/server": "1.0.38",
 		"@datasert/cronjs-parser": "^1.4.0",
 		"@vitejs/plugin-react": "^5.1.2",
 		"acorn-loose": "^8.5.2",
@@ -60,10 +60,10 @@
 		"typescript": "^5.9.0",
 		"vite": "^7.2.7",
 		"zod": "^4.3.5",
-		"@agentuity/frontend": "1.0.36"
+		"@agentuity/frontend": "1.0.38"
 	},
 	"devDependencies": {
-		"@agentuity/test-utils": "1.0.36",
+		"@agentuity/test-utils": "1.0.38",
 		"@types/adm-zip": "^0.5.7",
 		"@types/bun": "latest",
 		"@types/tar-fs": "^2.0.4",

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

@@ -42,6 +42,10 @@ const SandboxCpResponseSchema = z.object({
 	destination: z.string().describe('Destination path'),
 	bytesTransferred: z.number().describe('Number of bytes transferred'),
 	filesTransferred: z.number().describe('Number of files transferred'),
+	directoriesCreated: z
+		.array(z.string())
+		.optional()
+		.describe('Parent directories auto-created on the destination'),
 });
 
 export const cpSubcommand = createCommand({
@@ -156,6 +160,30 @@ function getAllFiles(dirPath: string, basePath: string = dirPath): string[] {
 	return files;
 }
 
+/**
+ * Computes the parent directories that would be auto-created by the server
+ * when writing files to the given paths. Filters out directories that always
+ * exist in a sandbox (/, /home, /home/agentuity).
+ */
+function getImplicitDirectories(filePaths: string[]): string[] {
+	const dirs = new Set<string>();
+	// Directories that always exist in a sandbox
+	const knownDirs = new Set(['/', '/home', '/home/agentuity']);
+
+	for (const filePath of filePaths) {
+		let dir = dirname(filePath);
+		while (dir && dir !== '.' && dir !== '/') {
+			if (!knownDirs.has(dir)) {
+				dirs.add(dir);
+			}
+			const parent = dirname(dir);
+			if (parent === dir) break;
+			dir = parent;
+		}
+	}
+	return Array.from(dirs).sort();
+}
+
 async function uploadToSandbox(
 	client: APIClient,
 	logger: Logger,
@@ -234,11 +262,13 @@ async function uploadSingleFile(
 		tui.success(`Copied ${displayPath} → ${sandboxId}:${targetPath} (${buffer.length} bytes)`);
 	}
 
+	const implicitDirs = getImplicitDirectories([targetPath]);
 	return {
 		source: displayPath,
 		destination: `${sandboxId}:${targetPath}`,
 		bytesTransferred: buffer.length,
 		filesTransferred: 1,
+		directoriesCreated: implicitDirs.length > 0 ? implicitDirs : undefined,
 	};
 }
 
@@ -281,11 +311,13 @@ async function uploadDirectory(
 		);
 	}
 
+	const implicitDirs = getImplicitDirectories(files.map((f) => f.path));
 	return {
 		source: localDir,
 		destination: `${sandboxId}:${baseRemotePath}`,
 		bytesTransferred: totalBytes,
 		filesTransferred: allFiles.length,
+		directoriesCreated: implicitDirs.length > 0 ? implicitDirs : undefined,
 	};
 }
 

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

@@ -15,6 +15,14 @@ const SandboxExecResponseSchema = z.object({
 	status: z.string().describe('Execution status'),
 	exitCode: z.number().optional().describe('Exit code (if completed)'),
 	durationMs: z.number().optional().describe('Duration in milliseconds (if completed)'),
+	stdout: z
+		.string()
+		.optional()
+		.describe('Standard output (only when separate streams are available)'),
+	stderr: z
+		.string()
+		.optional()
+		.describe('Standard error output (only when separate streams are available)'),
 	output: z.string().optional().describe('Combined stdout/stderr output'),
 });
 
@@ -68,16 +76,6 @@ export const execSubcommand = createCommand({
 		process.on('SIGINT', handleSignal);
 		process.on('SIGTERM', handleSignal);
 
-		const outputChunks: string[] = [];
-
-		// For JSON output, capture to buffer; otherwise stream to process
-		const stdout = options.json
-			? createCaptureStream((chunk) => outputChunks.push(chunk))
-			: process.stdout;
-		const stderr = options.json
-			? createCaptureStream((chunk) => outputChunks.push(chunk))
-			: process.stderr;
-
 		try {
 			const execution = await sandboxExecute(client, {
 				sandboxId: args.sandboxId,
@@ -98,24 +96,69 @@ export const execSubcommand = createCommand({
 			const isCombinedOutput =
 				stdoutStreamUrl && stderrStreamUrl && stdoutStreamUrl === stderrStreamUrl;
 
+			// Set up stream capture — in JSON mode, capture to buffers;
+			// when streams are separate, capture stdout/stderr independently
+			const outputChunks: string[] = [];
+			const stdoutChunks: string[] = [];
+			const stderrChunks: string[] = [];
+
+			let stdoutWritable: NodeJS.WritableStream;
+			let stderrWritable: NodeJS.WritableStream;
+
+			if (options.json) {
+				if (isCombinedOutput) {
+					// Combined stream: can't distinguish stdout from stderr
+					stdoutWritable = createCaptureStream((chunk) => outputChunks.push(chunk));
+					stderrWritable = createCaptureStream((chunk) => outputChunks.push(chunk));
+				} else {
+					// Separate streams: capture each independently and also to combined output
+					stdoutWritable = createCaptureStream((chunk) => {
+						stdoutChunks.push(chunk);
+						outputChunks.push(chunk);
+					});
+					stderrWritable = createCaptureStream((chunk) => {
+						stderrChunks.push(chunk);
+						outputChunks.push(chunk);
+					});
+				}
+			} else {
+				stdoutWritable = process.stdout;
+				stderrWritable = process.stderr;
+			}
+
 			if (isCombinedOutput) {
 				// Stream combined output to stdout only to avoid duplicates
 				logger.debug('using combined output stream (stdout === stderr): %s', stdoutStreamUrl);
 				streamPromises.push(
-					streamUrlToWritable(stdoutStreamUrl, stdout, streamAbortController.signal, logger)
+					streamUrlToWritable(
+						stdoutStreamUrl,
+						stdoutWritable,
+						streamAbortController.signal,
+						logger
+					)
 				);
 			} else {
 				if (stdoutStreamUrl) {
 					logger.debug('starting stdout stream from: %s', stdoutStreamUrl);
 					streamPromises.push(
-						streamUrlToWritable(stdoutStreamUrl, stdout, streamAbortController.signal, logger)
+						streamUrlToWritable(
+							stdoutStreamUrl,
+							stdoutWritable,
+							streamAbortController.signal,
+							logger
+						)
 					);
 				}
 
 				if (stderrStreamUrl) {
 					logger.debug('starting stderr stream from: %s', stderrStreamUrl);
 					streamPromises.push(
-						streamUrlToWritable(stderrStreamUrl, stderr, streamAbortController.signal, logger)
+						streamUrlToWritable(
+							stderrStreamUrl,
+							stderrWritable,
+							streamAbortController.signal,
+							logger
+						)
 					);
 				}
 			}
@@ -145,6 +188,10 @@ export const execSubcommand = createCommand({
 
 			const duration = Date.now() - started;
 			const output = outputChunks.join('');
+			const stdoutOutput =
+				!isCombinedOutput && stdoutStreamUrl ? stdoutChunks.join('') : undefined;
+			const stderrOutput =
+				!isCombinedOutput && stderrStreamUrl ? stderrChunks.join('') : undefined;
 
 			if (!options.json) {
 				if (finalExecution.exitCode === 0) {
@@ -163,6 +210,8 @@ export const execSubcommand = createCommand({
 				status: finalExecution.status,
 				exitCode: finalExecution.exitCode,
 				durationMs: finalExecution.durationMs,
+				stdout: options.json ? stdoutOutput : undefined,
+				stderr: options.json ? stderrOutput : undefined,
 				output: options.json ? output : undefined,
 			};
 		} finally {

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

@@ -95,7 +95,7 @@ export const createSubcommand = createCommand({
 				.optional()
 				.describe('task priority (default: none)'),
 			status: z
-				.enum(['open', 'in_progress', 'closed', 'done', 'cancelled'])
+				.enum(['open', 'in_progress', 'done', 'cancelled'])
 				.optional()
 				.describe('initial task status (default: open)'),
 			parentId: z.string().optional().describe('parent task ID for subtasks'),

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

@@ -70,8 +70,8 @@ export const deleteSubcommand = createCommand({
 			description: 'Delete a single task by ID',
 		},
 		{
-			command: getCommand('cloud task delete --status closed --older-than 7d'),
-			description: 'Delete closed tasks older than 7 days',
+			command: getCommand('cloud task delete --status done --older-than 7d'),
+			description: 'Delete done tasks older than 7 days',
 		},
 		{
 			command: getCommand('cloud task delete --status done --limit 10 --dry-run'),
@@ -88,7 +88,7 @@ export const deleteSubcommand = createCommand({
 		}),
 		options: z.object({
 			status: z
-				.enum(['open', 'in_progress', 'done', 'closed', 'cancelled'])
+				.enum(['open', 'in_progress', 'done', 'cancelled'])
 				.optional()
 				.describe('filter batch delete by status'),
 			type: z

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

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 import { createCommand } from '../../../types';
 import * as tui from '../../../tui';
-import { createStorageAdapter, cacheTaskId } from './util';
+import { createStorageAdapterOptionalOrg, cacheTaskId } from './util';
 import { getCommand } from '../../../command-prefix';
 
 const EntityRefSchema = z
@@ -19,6 +19,15 @@ const UserEntityRefSchema = z
 	})
 	.optional();
 
+const SubtaskSchema = z.object({
+	id: z.string().describe('Subtask ID'),
+	title: z.string().describe('Subtask title'),
+	type: z.string().describe('Subtask type'),
+	status: z.string().describe('Subtask status'),
+	priority: z.string().describe('Subtask priority'),
+	assignee: UserEntityRefSchema.describe('Subtask assignee'),
+});
+
 const TaskGetResponseSchema = z.object({
 	success: z.boolean().describe('Whether the operation succeeded'),
 	task: z.object({
@@ -41,6 +50,7 @@ const TaskGetResponseSchema = z.object({
 		closed_date: z.string().optional().describe('Date task was closed'),
 		cancelled_date: z.string().optional().describe('Date task was cancelled'),
 	}),
+	subtasks: z.array(SubtaskSchema).optional().describe('Subtasks of this task'),
 	durationMs: z.number().describe('Operation duration in milliseconds'),
 });
 
@@ -60,21 +70,27 @@ export const getSubcommand = createCommand({
 			command: getCommand('cloud task get task_abc123 --json'),
 			description: 'Get task details as JSON',
 		},
+		{
+			command: getCommand('cloud task get task_abc123 --no-subtasks'),
+			description: 'Get task details without subtasks',
+		},
 	],
 	schema: {
 		args: z.object({
 			id: z.string().min(1).describe('the task ID to get'),
 		}),
+		options: z.object({
+			'no-subtasks': z.boolean().optional().describe('Do not show subtasks'),
+		}),
 		response: TaskGetResponseSchema,
 	},
 
 	async handler(ctx) {
-		const { args, options } = ctx;
+		const { args, opts, options } = ctx;
 		const started = Date.now();
-		const storage = await createStorageAdapter(ctx);
+		const storage = await createStorageAdapterOptionalOrg(ctx);
 
 		const task = await storage.get(args.id);
-		const durationMs = Date.now() - started;
 
 		if (!task) {
 			tui.fatal(`Task not found: ${args.id}`);
@@ -82,6 +98,37 @@ export const getSubcommand = createCommand({
 
 		await cacheTaskId(ctx, task.id);
 
+		// Fetch subtasks unless disabled
+		let subtasksList: {
+			id: string;
+			title: string;
+			type: string;
+			status: string;
+			priority: string;
+			assignee?: { id: string; name: string; type?: 'human' | 'agent' };
+		}[] = [];
+		let subtasksError: string | undefined;
+		if (!opts['no-subtasks']) {
+			try {
+				const subtasksResult = await storage.list({ parent_id: task.id });
+				subtasksList = subtasksResult.tasks.map((st) => ({
+					id: st.id,
+					title: st.title,
+					type: st.type,
+					status: st.status,
+					priority: st.priority,
+					assignee: st.assignee,
+				}));
+			} catch (err) {
+				subtasksError = err instanceof Error ? err.message : 'Failed to fetch subtasks';
+				if (!options.json) {
+					tui.warn(`Could not load subtasks: ${subtasksError}`);
+				}
+			}
+		}
+
+		const durationMs = Date.now() - started;
+
 		if (!options.json) {
 			const tableData: Record<string, string> = {
 				ID: task.id,
@@ -133,6 +180,21 @@ export const getSubcommand = createCommand({
 				tui.header('Metadata');
 				tui.json(task.metadata);
 			}
+
+			// Show subtasks
+			if (subtasksList.length > 0) {
+				tui.newline();
+				tui.header('Subtasks');
+				const subtaskRows = subtasksList.map((st) => ({
+					ID: st.id,
+					Title: st.title,
+					Type: st.type,
+					Status: st.status,
+					Priority: st.priority,
+					Assignee: st.assignee?.name ?? 'Unassigned',
+				}));
+				tui.table(subtaskRows, ['ID', 'Title', 'Type', 'Status', 'Priority', 'Assignee']);
+			}
 		}
 
 		return {
@@ -157,6 +219,8 @@ export const getSubcommand = createCommand({
 				closed_date: task.closed_date,
 				cancelled_date: task.cancelled_date,
 			},
+			subtasks: subtasksList.length > 0 ? subtasksList : undefined,
+			subtasksError,
 			durationMs,
 		};
 	},

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

@@ -6,6 +6,8 @@ import { listSubcommand } from './list';
 import { deleteSubcommand } from './delete';
 import { statsSubcommand } from './stats';
 import { attachmentSubcommand } from './attachment';
+import { userSubcommand } from './user';
+import { projectSubcommand } from './project';
 import { getCommand } from '../../../command-prefix';
 
 export const taskCommand = createCommand({
@@ -34,13 +36,21 @@ export const taskCommand = createCommand({
 			description: 'Delete a task by ID',
 		},
 		{
-			command: getCommand('cloud task delete --status closed --older-than 7d'),
-			description: 'Batch delete closed tasks older than 7 days',
+			command: getCommand('cloud task delete --status done --older-than 7d'),
+			description: 'Batch delete done tasks older than 7 days',
 		},
 		{
 			command: getCommand('cloud task attachment upload task_abc123 ./report.pdf'),
 			description: 'Upload a file attachment to a task',
 		},
+		{
+			command: getCommand('cloud task user list'),
+			description: 'List task users',
+		},
+		{
+			command: getCommand('cloud task project list'),
+			description: 'List task projects',
+		},
 	],
 	subcommands: [
 		getSubcommand,
@@ -50,6 +60,8 @@ export const taskCommand = createCommand({
 		deleteSubcommand,
 		statsSubcommand,
 		attachmentSubcommand,
+		userSubcommand,
+		projectSubcommand,
 	],
 	requires: { auth: true },
 });

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

@@ -55,7 +55,6 @@ const STATUS_COLORS: Record<string, (s: string) => string> = {
 	open: tui.colorSuccess,
 	in_progress: tui.colorWarning,
 	done: tui.colorInfo,
-	closed: tui.muted,
 	cancelled: tui.muted,
 };
 
@@ -108,7 +107,7 @@ export const listSubcommand = createCommand({
 	schema: {
 		options: z.object({
 			status: z
-				.enum(['open', 'in_progress', 'done', 'closed', 'cancelled'])
+				.enum(['open', 'in_progress', 'done', 'cancelled'])
 				.optional()
 				.describe('filter by status'),
 			type: z

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

@@ -0,0 +1,227 @@
+import { z } from 'zod';
+import { createCommand } from '../../../types';
+import * as tui from '../../../tui';
+import { createStorageAdapter } from './util';
+import { getCommand } from '../../../command-prefix';
+
+// ── List ────────────────────────────────────────────────────────────────
+
+const listProjectsSubcommand = createCommand({
+	name: 'list',
+	aliases: ['ls'],
+	description: 'List all task projects',
+	tags: ['read-only', 'slow', 'requires-auth'],
+	requires: { auth: true },
+	idempotent: true,
+	examples: [
+		{
+			command: getCommand('cloud task project list'),
+			description: 'List all projects',
+		},
+	],
+	schema: {
+		response: z.object({
+			success: z.boolean(),
+			projects: z.array(z.object({ id: z.string(), name: z.string() })),
+			total: z.number(),
+			durationMs: z.number(),
+		}),
+	},
+
+	async handler(ctx) {
+		const { options } = ctx;
+		const started = Date.now();
+		const storage = await createStorageAdapter(ctx);
+		const result = await storage.listProjects();
+		const durationMs = Date.now() - started;
+
+		if (!options.json) {
+			if (result.projects.length === 0) {
+				tui.info('No projects found.');
+			} else {
+				tui.table(
+					result.projects.map((p) => ({ id: p.id, name: p.name })),
+					['id', 'name']
+				);
+				tui.info(`${result.projects.length} project(s) (${durationMs.toFixed(1)}ms)`);
+			}
+		}
+
+		return {
+			success: true,
+			projects: result.projects,
+			total: result.projects.length,
+			durationMs,
+		};
+	},
+});
+
+// ── Create ──────────────────────────────────────────────────────────────
+
+const createProjectSubcommand = createCommand({
+	name: 'create',
+	description: 'Create a new task project',
+	tags: ['mutating', 'slow', 'requires-auth'],
+	requires: { auth: true },
+	examples: [
+		{
+			command: getCommand('cloud task project create "My Project"'),
+			description: 'Create a new project',
+		},
+	],
+	schema: {
+		args: z.object({
+			name: z.string().min(1).describe('the project name'),
+		}),
+		response: z.object({
+			success: z.boolean(),
+			project: z.object({ id: z.string(), name: z.string() }),
+			durationMs: z.number(),
+		}),
+	},
+
+	async handler(ctx) {
+		const { args, options } = ctx;
+		const started = Date.now();
+		const storage = await createStorageAdapter(ctx);
+		const project = await storage.createProject({ name: args.name });
+		const durationMs = Date.now() - started;
+
+		if (!options.json) {
+			tui.success(`Created project: ${project.name} (${project.id})`);
+		}
+
+		return { success: true, project, durationMs };
+	},
+});
+
+// ── Get ─────────────────────────────────────────────────────────────────
+
+const getProjectSubcommand = createCommand({
+	name: 'get',
+	description: 'Get a task project by ID',
+	tags: ['read-only', 'slow', 'requires-auth'],
+	requires: { auth: true },
+	idempotent: true,
+	examples: [
+		{
+			command: getCommand('cloud task project get prj_abc123'),
+			description: 'Get project details',
+		},
+	],
+	schema: {
+		args: z.object({
+			id: z.string().min(1).describe('the project ID'),
+		}),
+		response: z.object({
+			success: z.boolean(),
+			project: z.object({ id: z.string(), name: z.string() }),
+			durationMs: z.number(),
+		}),
+	},
+
+	async handler(ctx) {
+		const { args, options } = ctx;
+		const started = Date.now();
+		const storage = await createStorageAdapter(ctx);
+		try {
+			const project = await storage.getProject(args.id);
+			const durationMs = Date.now() - started;
+
+			if (!options.json) {
+				tui.table([{ id: project.id, name: project.name }], ['id', 'name'], {
+					layout: 'vertical',
+				});
+			}
+
+			return { success: true, project, durationMs };
+		} catch (_err) {
+			const durationMs = Date.now() - started;
+			if (!options.json) {
+				tui.error(`Project not found: ${args.id}`);
+			}
+			return { success: false, project: { id: args.id, name: '' }, durationMs };
+		}
+	},
+});
+
+// ── Delete ──────────────────────────────────────────────────────────────
+
+const deleteProjectSubcommand = createCommand({
+	name: 'delete',
+	aliases: ['del', 'rm'],
+	description: 'Delete a task project',
+	tags: ['mutating', 'slow', 'requires-auth', 'destructive'],
+	requires: { auth: true },
+	examples: [
+		{
+			command: getCommand('cloud task project delete prj_abc123'),
+			description: 'Delete a project',
+		},
+	],
+	schema: {
+		args: z.object({
+			id: z.string().min(1).describe('the project ID'),
+		}),
+		response: z.object({
+			success: z.boolean(),
+			durationMs: z.number(),
+		}),
+	},
+
+	async handler(ctx) {
+		const { args, options } = ctx;
+		const started = Date.now();
+		const storage = await createStorageAdapter(ctx);
+		try {
+			await storage.deleteProject(args.id);
+			const durationMs = Date.now() - started;
+
+			if (!options.json) {
+				tui.success(`Deleted project: ${args.id}`);
+			}
+
+			return { success: true, durationMs };
+		} catch (_err) {
+			const durationMs = Date.now() - started;
+			if (!options.json) {
+				tui.error(`Failed to delete project: ${args.id}`);
+			}
+			return { success: false, durationMs };
+		}
+	},
+});
+
+// ── Parent command ──────────────────────────────────────────────────────
+
+export const projectSubcommand = createCommand({
+	name: 'project',
+	aliases: ['proj'],
+	description: 'Manage task projects',
+	tags: ['requires-auth'],
+	requires: { auth: true },
+	examples: [
+		{
+			command: getCommand('cloud task project list'),
+			description: 'List all projects',
+		},
+		{
+			command: getCommand('cloud task project create "My Project"'),
+			description: 'Create a new project',
+		},
+		{
+			command: getCommand('cloud task project get prj_abc123'),
+			description: 'Get project details',
+		},
+		{
+			command: getCommand('cloud task project delete prj_abc123'),
+			description: 'Delete a project',
+		},
+	],
+	subcommands: [
+		listProjectsSubcommand,
+		createProjectSubcommand,
+		getProjectSubcommand,
+		deleteProjectSubcommand,
+	],
+});

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

@@ -55,7 +55,10 @@ export const updateSubcommand = createCommand({
 				.enum(['epic', 'feature', 'enhancement', 'bug', 'task'])
 				.optional()
 				.describe('new task type'),
-			status: z.enum(['open', 'in_progress', 'closed']).optional().describe('new task status'),
+			status: z
+				.enum(['open', 'in_progress', 'done', 'cancelled'])
+				.optional()
+				.describe('new task status'),
 			assignedId: z.string().optional().describe('new assigned agent or user ID'),
 			parentId: z.string().optional().describe('new parent task ID'),
 			closedId: z.string().optional().describe('ID of the closer (agent or user)'),