@agentuity/cli 1.0.36 → 1.0.37

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@agentuity/cli",
-	"version": "1.0.36",
+	"version": "1.0.37",
 	"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.37",
+		"@agentuity/core": "1.0.37",
+		"@agentuity/server": "1.0.37",
 		"@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.37"
 	},
 	"devDependencies": {
-		"@agentuity/test-utils": "1.0.36",
+		"@agentuity/test-utils": "1.0.37",
 		"@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/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/util.ts

@@ -36,6 +36,24 @@ export async function createStorageAdapter(ctx: TaskContext) {
 	return new TaskStorageService(baseUrl, adapter);
 }
 
+export async function createStorageAdapterOptionalOrg(ctx: TaskContext) {
+	const orgId =
+		ctx.options.orgId ?? (process.env.AGENTUITY_CLOUD_ORG_ID || ctx.config?.preferences?.orgId);
+
+	const headers: Record<string, string> = {
+		Authorization: `Bearer ${ctx.auth.apiKey}`,
+	};
+	if (orgId) {
+		headers['x-agentuity-orgid'] = orgId;
+	}
+
+	const adapter = createServerFetchAdapter({ headers }, ctx.logger);
+
+	const region = await getDefaultRegion(ctx.config?.name ?? defaultProfileName, ctx.config);
+	const baseUrl = getCatalystUrl(region, ctx.config?.overrides);
+	return new TaskStorageService(baseUrl, adapter);
+}
+
 export async function cacheTaskId(
 	ctx: {
 		config: Config | null;

package/src/cmd/coder/hub-url.ts

@@ -0,0 +1,105 @@
+/**
+ * Hub URL resolution for Coder CLI commands.
+ *
+ * Resolution priority:
+ *   1. --hub-url flag (explicit per-command override)
+ *   2. AGENTUITY_CODER_HUB_URL env var
+ *   3. AGENTUITY_DEVMODE_URL env var (dev tunnel URL)
+ */
+
+import { getVersion } from '../../version';
+
+/**
+ * Resolve the Hub HTTP base URL for REST API calls.
+ * Converts ws:// URLs to http:// automatically.
+ *
+ * @param flagUrl  Optional --hub-url flag value
+ * @returns HTTP base URL (e.g. "http://localhost:3500") or null if Hub is unreachable
+ */
+export async function resolveHubUrl(flagUrl?: string): Promise<string | null> {
+	// 1. Explicit flag
+	if (flagUrl) return normalizeToHttp(flagUrl);
+
+	// 2. Env var (explicit)
+	const envUrl = process.env.AGENTUITY_CODER_HUB_URL;
+	if (envUrl) return normalizeToHttp(envUrl);
+
+	// 3. Dev mode URL (tunnel)
+	const devUrl = process.env.AGENTUITY_DEVMODE_URL;
+	if (devUrl) return normalizeToHttp(devUrl);
+
+	return null;
+}
+
+/**
+ * Resolve the Hub WebSocket URL for Pi extension connections.
+ * Converts http:// URLs to ws:// automatically and ensures /api/ws path.
+ *
+ * @param flagUrl  Optional --hub-url flag value
+ * @returns WebSocket URL (e.g. "ws://127.0.0.1:3500/api/ws") or null
+ */
+export async function resolveHubWsUrl(flagUrl?: string): Promise<string | null> {
+	const httpUrl = await resolveHubUrl(flagUrl);
+	if (!httpUrl) return null;
+	return normalizeToWs(httpUrl);
+}
+
+/**
+ * Convert any URL form to an HTTP base URL (strip paths, convert ws->http).
+ */
+function normalizeToHttp(url: string): string {
+	let normalized = url.trim().replace(/\/+$/, '');
+
+	// ws:// -> http://
+	if (normalized.startsWith('ws://')) normalized = 'http://' + normalized.slice(5);
+	else if (normalized.startsWith('wss://')) normalized = 'https://' + normalized.slice(6);
+
+	// Strip /api/ws or /api/hub/* paths to get base URL
+	normalized = normalized.replace(/\/api\/ws\b.*$/, '');
+	normalized = normalized.replace(/\/api\/hub\b.*$/, '');
+
+	return normalized.replace(/\/+$/, '');
+}
+
+/**
+ * Convert an HTTP base URL to a WebSocket URL with /api/ws path.
+ */
+function normalizeToWs(httpUrl: string): string {
+	let wsUrl = httpUrl;
+	if (wsUrl.startsWith('http://')) wsUrl = 'ws://' + wsUrl.slice(7);
+	else if (wsUrl.startsWith('https://')) wsUrl = 'wss://' + wsUrl.slice(8);
+
+	try {
+		const parsed = new URL(wsUrl);
+		if (parsed.pathname !== '/api/ws') {
+			parsed.pathname = '/api/ws';
+			wsUrl = parsed.toString().replace(/\/$/, '');
+		}
+	} catch {
+		if (!wsUrl.endsWith('/api/ws')) {
+			wsUrl = wsUrl.replace(/\/?$/, '/api/ws');
+		}
+	}
+
+	return wsUrl;
+}
+
+/**
+ * Resolve the API key for Hub authentication.
+ * TODO: Remove/Change when we get Agentuity service level auth enabled, this is just temporary
+ */
+export function resolveApiKey(): string | null {
+	return process.env.AGENTUITY_CODER_API_KEY || null;
+}
+
+/**
+ * Build headers object with API key if available.
+ * TODO: Remove/Change when we get Agentuity service level auth enabled, this is just temporary
+ */
+export function hubFetchHeaders(extra?: Record<string, string>): Record<string, string> {
+	const headers: Record<string, string> = { ...extra };
+	headers['User-Agent'] = `Agentuity Coder/${getVersion()}`;
+	const apiKey = resolveApiKey();
+	if (apiKey) headers['x-agentuity-auth-api-key'] = apiKey;
+	return headers;
+}

package/src/cmd/coder/index.ts

@@ -0,0 +1,27 @@
+import { createCommand } from '../../types';
+import { listSubcommand } from './list';
+import { inspectSubcommand } from './inspect';
+import { startSubcommand } from './start';
+import { getCommand } from '../../command-prefix';
+
+export const command = createCommand({
+	name: 'coder',
+	description: 'Coder Hub session management commands',
+	tags: ['requires-auth'],
+	examples: [
+		{
+			command: getCommand('coder start'),
+			description: 'Start a Pi session connected to the Coder Hub',
+		},
+		{
+			command: getCommand('coder ls'),
+			description: 'List all active Coder Hub sessions',
+		},
+		{
+			command: getCommand('coder inspect <session-id>'),
+			description: 'Show detailed session information',
+		},
+	],
+	subcommands: [startSubcommand, listSubcommand, inspectSubcommand],
+	optional: { auth: true },
+});