@agentuity/cli 2.0.7 → 2.0.8

package/src/cmd/coder/{inspect.ts → get.ts}

@@ -1,22 +1,20 @@
 import { z } from 'zod';
+import {
+	CoderClient,
+	CoderSessionArchivedError,
+	CoderSessionNotFoundError,
+} from '@agentuity/core/coder';
+import { ValidationOutputError } from '@agentuity/core';
+
 import { createSubcommand } from '../../types';
 import * as tui from '../../tui';
 import { getCommand } from '../../command-prefix';
 import { ErrorCode } from '../../errors';
-import {
-	clearStoredHubApiKeyOnUnauthorized,
-	formatHubUnauthorizedMessage,
-	formatMissingHubUrlMessage,
-	getHubResponseErrorMessage,
-	getHubUrlSetupGuidance,
-	hubFetchHeaders,
-	isHubUnauthorizedStatus,
-	resolveHubApiKey,
-	resolveHubUrl,
-} from './hub-url';
 
 function formatRelativeTime(isoDate: string): string {
-	const diffMs = Date.now() - new Date(isoDate).getTime();
+	const parsed = new Date(isoDate).getTime();
+	if (Number.isNaN(parsed)) return 'unknown';
+	const diffMs = Math.max(0, Date.now() - parsed);
 	const seconds = Math.floor(diffMs / 1000);
 	if (seconds < 60) return `${seconds}s ago`;
 	const minutes = Math.floor(seconds / 60);
@@ -38,17 +36,19 @@ function formatDuration(ms: number): string {
 	return `${hours}h ${remainMin}m`;
 }
 
-export const inspectSubcommand = createSubcommand({
-	name: 'inspect',
+export const getSubcommand = createSubcommand({
+	name: 'get',
+	aliases: ['show', 'inspect'],
 	description: 'Show detailed information about a Coder Hub session',
 	tags: ['read-only', 'fast', 'requires-auth'],
+	requires: { auth: true, org: true },
 	examples: [
 		{
-			command: getCommand('coder inspect codesess_abc123'),
-			description: 'Inspect a session by ID',
+			command: getCommand('coder get codesess_abc123'),
+			description: 'Get a session by ID',
 		},
 		{
-			command: getCommand('coder inspect codesess_abc123 --json'),
+			command: getCommand('coder get codesess_abc123 --json'),
 			description: 'Get session details as JSON',
 		},
 	],
@@ -58,20 +58,17 @@ export const inspectSubcommand = createSubcommand({
 			session_id: z.string().describe('Coder session ID to inspect'),
 		}),
 		options: z.object({
-			hubUrl: z.string().optional().describe('Hub URL override'),
+			url: z.string().optional().describe('Coder API URL override'),
 		}),
 	},
 	async handler(ctx) {
-		const { args, options, opts, config } = ctx;
+		const { args, options, opts } = ctx;
 		const sessionId = args.session_id;
-		const hubUrl = await resolveHubUrl(opts?.hubUrl, config);
-
-		if (!hubUrl) {
-			tui.fatal(formatMissingHubUrlMessage(), ErrorCode.NETWORK_ERROR);
-			return;
-		}
-
-		const resolvedHubApiKey = await resolveHubApiKey(config);
+		const client = new CoderClient({
+			apiKey: ctx.auth.apiKey,
+			url: opts?.url,
+			orgId: ctx.orgId,
+		});
 
 		let data: {
 			sessionId: string;
@@ -79,18 +76,18 @@ export const inspectSubcommand = createSubcommand({
 			status: string;
 			createdAt: string;
 			mode: string;
-			context: {
+			context?: {
 				branch?: string;
 				workingDirectory?: string;
 			};
-			participants: Array<{
+			participants?: Array<{
 				id: string;
 				role: string;
 				transport: string;
 				connectedAt: string;
 				idle: boolean;
 			}>;
-			tasks: Array<{
+			tasks?: Array<{
 				taskId: string;
 				agent: string;
 				status: string;
@@ -99,7 +96,7 @@ export const inspectSubcommand = createSubcommand({
 				startedAt: string;
 				completedAt?: string;
 			}>;
-			agentActivity: Record<
+			agentActivity?: Record<
 				string,
 				{
 					name: string;
@@ -112,46 +109,23 @@ export const inspectSubcommand = createSubcommand({
 		};
 
 		try {
-			const resp = await fetch(`${hubUrl}/api/hub/session/${encodeURIComponent(sessionId)}`, {
-				headers: hubFetchHeaders(undefined, resolvedHubApiKey.apiKey),
-				signal: AbortSignal.timeout(10_000),
-			});
-			if (isHubUnauthorizedStatus(resp.status)) {
-				const message = await getHubResponseErrorMessage(resp);
-				const clearedStoredKey = await clearStoredHubApiKeyOnUnauthorized(
-					resp.status,
-					resolvedHubApiKey,
-					config
-				);
-				tui.fatal(
-					formatHubUnauthorizedMessage(hubUrl, message, { clearedStoredKey }),
-					ErrorCode.API_ERROR
-				);
-				return;
-			}
-			if (resp.status === 404) {
+			data = (await client.getSession(sessionId)) as unknown as typeof data;
+		} catch (err) {
+			if (err instanceof CoderSessionNotFoundError) {
 				tui.fatal(`Session not found: ${sessionId}`, ErrorCode.RESOURCE_NOT_FOUND);
 				return;
 			}
-			if (resp.status === 410) {
+			if (err instanceof CoderSessionArchivedError) {
 				tui.fatal(`Session has shut down: ${sessionId}`, ErrorCode.RESOURCE_NOT_FOUND);
 				return;
 			}
-			if (!resp.ok) {
-				const message = await getHubResponseErrorMessage(resp);
-				tui.fatal(
-					`Hub returned ${resp.status}: ${message}. Is the Coder Hub running at ${hubUrl}?`,
-					ErrorCode.API_ERROR
-				);
-				return;
+
+			if (err instanceof ValidationOutputError) {
+				ctx.logger.trace('Validation response URL: %s', err.url ?? 'unknown');
+				ctx.logger.trace('Validation issues: %s', JSON.stringify(err.issues, null, 2));
 			}
-			data = (await resp.json()) as typeof data;
-		} catch (err) {
 			const msg = err instanceof Error ? err.message : String(err);
-			tui.fatal(
-				`Could not connect to Coder Hub at ${hubUrl}: ${msg}\n\n${getHubUrlSetupGuidance()}`,
-				ErrorCode.NETWORK_ERROR
-			);
+			tui.fatal(`Failed to inspect Coder session ${sessionId}: ${msg}`, ErrorCode.NETWORK_ERROR);
 			return;
 		}
 
@@ -164,17 +138,18 @@ export const inspectSubcommand = createSubcommand({
 		console.log();
 		console.log(`  Session: ${label} (${data.sessionId})`);
 		const parts = [`Status: ${data.status}`, `Mode: ${data.mode}`];
-		if (data.context.branch) parts.push(`Branch: ${data.context.branch}`);
+		if (data.context?.branch) parts.push(`Branch: ${data.context.branch}`);
 		console.log(`  ${parts.join(' | ')}`);
 		console.log(`  Created: ${data.createdAt}`);
 
 		// Participants
 		console.log();
 		console.log('  Participants:');
-		if (data.participants.length === 0) {
+		const participants = data.participants ?? [];
+		if (participants.length === 0) {
 			console.log('    (none)');
 		} else {
-			for (const p of data.participants) {
+			for (const p of participants) {
 				const idle = p.idle ? '  (idle)' : '';
 				const connected = p.connectedAt
 					? `  connected ${formatRelativeTime(p.connectedAt)}`
@@ -186,10 +161,11 @@ export const inspectSubcommand = createSubcommand({
 		}
 
 		// Tasks
-		if (data.tasks.length > 0) {
+		const tasks = data.tasks ?? [];
+		if (tasks.length > 0) {
 			console.log();
 			console.log('  Tasks:');
-			for (const t of data.tasks) {
+			for (const t of tasks) {
 				const dur = t.duration ? formatDuration(t.duration) : '-';
 				const prompt = t.prompt.length > 40 ? t.prompt.slice(0, 37) + '...' : t.prompt;
 				console.log(
@@ -199,7 +175,7 @@ export const inspectSubcommand = createSubcommand({
 		}
 
 		// Agent Activity
-		const agents = Object.values(data.agentActivity);
+		const agents = Object.values(data.agentActivity ?? {});
 		if (agents.length > 0) {
 			console.log();
 			console.log('  Agent Activity:');

package/src/cmd/coder/index.ts

@@ -1,8 +1,18 @@
 import { createCommand } from '../../types';
-import { configSubcommand } from './config';
 import { listSubcommand } from './list';
-import { inspectSubcommand } from './inspect';
+import { getSubcommand } from './get';
 import { startSubcommand } from './start';
+import { createCoderSubcommand } from './create';
+import { deleteSubcommand } from './delete';
+import { archiveSubcommand } from './archive';
+import { updateSubcommand } from './update';
+import { usersSubcommand } from './users';
+import { loopSubcommand } from './loop';
+import { replaySubcommand } from './replay';
+import { participantsSubcommand } from './participants';
+import { eventsSubcommand } from './events';
+import { workspaceCommand } from './workspace';
+import { skillCommand } from './skill';
 import { getCommand } from '../../command-prefix';
 
 export const command = createCommand({
@@ -14,19 +24,54 @@ export const command = createCommand({
 			command: getCommand('coder start'),
 			description: 'Start a Pi session connected to the Coder Hub',
 		},
+		{
+			command: getCommand('coder create "Build a REST API"'),
+			description: 'Create a new Coder session with a task',
+		},
 		{
 			command: getCommand('coder ls'),
 			description: 'List all active Coder Hub sessions',
 		},
 		{
-			command: getCommand('coder inspect <session-id>'),
+			command: getCommand('coder get <session-id>'),
 			description: 'Show detailed session information',
 		},
 		{
-			command: getCommand('coder config set url https://hub.example.com'),
-			description: 'Set the default Coder Hub URL for this profile',
+			command: getCommand('coder users'),
+			description: 'List known Coder Hub users',
+		},
+		{
+			command: getCommand('coder loop <session-id>'),
+			description: 'Get loop state for a session',
+		},
+		{
+			command: getCommand('coder events <session-id> --limit 100'),
+			description: 'Show recent event history for a session',
 		},
+		{
+			command: getCommand('coder workspace list'),
+			description: 'List Coder workspaces',
+		},
+		{
+			command: getCommand('coder skill list'),
+			description: 'List saved skills',
+		},
+	],
+	subcommands: [
+		startSubcommand,
+		createCoderSubcommand,
+		listSubcommand,
+		getSubcommand,
+		updateSubcommand,
+		deleteSubcommand,
+		archiveSubcommand,
+		usersSubcommand,
+		loopSubcommand,
+		replaySubcommand,
+		participantsSubcommand,
+		eventsSubcommand,
+		workspaceCommand,
+		skillCommand,
 	],
-	subcommands: [startSubcommand, listSubcommand, inspectSubcommand, configSubcommand],
-	optional: { auth: true },
+	requires: { auth: true, org: true },
 });

package/src/cmd/coder/list.ts

@@ -1,22 +1,19 @@
 import { z } from 'zod';
+import {
+	CoderClient,
+	type CoderSessionListItem,
+	CoderSessionListItemSchema,
+} from '@agentuity/core/coder';
+import { ValidationOutputError } from '@agentuity/core';
 import { createSubcommand } from '../../types';
 import * as tui from '../../tui';
 import { getCommand } from '../../command-prefix';
 import { ErrorCode } from '../../errors';
-import {
-	clearStoredHubApiKeyOnUnauthorized,
-	formatHubUnauthorizedMessage,
-	formatMissingHubUrlMessage,
-	getHubResponseErrorMessage,
-	getHubUrlSetupGuidance,
-	hubFetchHeaders,
-	isHubUnauthorizedStatus,
-	resolveHubApiKey,
-	resolveHubUrl,
-} from './hub-url';
 
 function formatRelativeTime(isoDate: string): string {
-	const diffMs = Date.now() - new Date(isoDate).getTime();
+	const parsed = new Date(isoDate).getTime();
+	if (Number.isNaN(parsed)) return 'unknown';
+	const diffMs = Math.max(0, Date.now() - parsed);
 	const seconds = Math.floor(diffMs / 1000);
 	if (seconds < 60) return `${seconds}s ago`;
 	const minutes = Math.floor(seconds / 60);
@@ -27,20 +24,6 @@ function formatRelativeTime(isoDate: string): string {
 	return `${days}d ago`;
 }
 
-const SessionListResponseSchema = z.array(
-	z.object({
-		sessionId: z.string().describe('Session ID'),
-		label: z.string().describe('Human-readable session label'),
-		status: z.string().describe('Session status'),
-		mode: z.string().describe('Session mode (sandbox or tui)'),
-		createdAt: z.string().describe('Creation timestamp'),
-		taskCount: z.number().describe('Number of tasks'),
-		subAgentCount: z.number().describe('Number of sub-agents'),
-		observerCount: z.number().describe('Number of observers'),
-		participantCount: z.number().describe('Total participant count'),
-	})
-);
-
 export const listSubcommand = createSubcommand({
 	name: 'list',
 	description: 'List active Coder Hub sessions',
@@ -57,79 +40,34 @@ export const listSubcommand = createSubcommand({
 	],
 	aliases: ['ls'],
 	idempotent: true,
+	requires: { auth: true, org: true },
 	schema: {
 		options: z.object({
-			hubUrl: z.string().optional().describe('Hub URL override'),
+			url: z.string().optional().describe('Coder API URL override'),
 		}),
-		response: SessionListResponseSchema,
+		response: z.array(CoderSessionListItemSchema),
 	},
 	async handler(ctx) {
-		const { options, opts, config } = ctx;
-		const hubUrl = await resolveHubUrl(opts?.hubUrl, config);
-
-		if (!hubUrl) {
-			tui.fatal(formatMissingHubUrlMessage(), ErrorCode.NETWORK_ERROR);
-			return [];
-		}
-
-		const resolvedHubApiKey = await resolveHubApiKey(config);
-
-		let data: {
-			sessions: {
-				websocket: Array<{
-					sessionId: string;
-					label: string;
-					status: string;
-					mode: string;
-					createdAt: string;
-					taskCount: number;
-					subAgentCount: number;
-					observerCount: number;
-					participantCount: number;
-				}>;
-				sandbox: Array<Record<string, unknown>>;
-			};
-			total: number;
-		};
+		const { options, opts } = ctx;
+		const client = new CoderClient({
+			apiKey: ctx.auth.apiKey,
+			url: opts?.url,
+			orgId: ctx.orgId,
+		});
 
+		let sessions: CoderSessionListItem[] = [];
 		try {
-			const resp = await fetch(`${hubUrl}/api/hub/sessions`, {
-				headers: hubFetchHeaders(undefined, resolvedHubApiKey.apiKey),
-				signal: AbortSignal.timeout(10_000),
-			});
-			if (!resp.ok) {
-				const message = await getHubResponseErrorMessage(resp);
-				if (isHubUnauthorizedStatus(resp.status)) {
-					const clearedStoredKey = await clearStoredHubApiKeyOnUnauthorized(
-						resp.status,
-						resolvedHubApiKey,
-						config
-					);
-					tui.fatal(
-						formatHubUnauthorizedMessage(hubUrl, message, { clearedStoredKey }),
-						ErrorCode.API_ERROR
-					);
-					return [];
-				}
-
-				tui.fatal(
-					`Hub returned ${resp.status}: ${message}. Is the Coder Hub running at ${hubUrl}?`,
-					ErrorCode.API_ERROR
-				);
-				return [];
-			}
-			data = (await resp.json()) as typeof data;
+			const response = await client.listSessions();
+			sessions = response.sessions;
 		} catch (err) {
+			if (err instanceof ValidationOutputError) {
+				ctx.logger.trace('Validation response URL: %s', err.url ?? 'unknown');
+				ctx.logger.trace('Validation issues: %s', JSON.stringify(err.issues, null, 2));
+			}
 			const msg = err instanceof Error ? err.message : String(err);
-			tui.fatal(
-				`Could not connect to Coder Hub at ${hubUrl}: ${msg}\n\n${getHubUrlSetupGuidance()}`,
-				ErrorCode.NETWORK_ERROR
-			);
-			return [];
+			tui.fatal(`Failed to list Coder sessions: ${msg}`, ErrorCode.NETWORK_ERROR);
 		}
 
-		const sessions = data.sessions.websocket;
-
 		if (options.json) {
 			return sessions;
 		}
@@ -140,10 +78,11 @@ export const listSubcommand = createSubcommand({
 		}
 
 		const tableData = sessions.map((s) => ({
-			'Session ID': s.sessionId.length > 20 ? s.sessionId.slice(0, 17) + '...' : s.sessionId,
+			'Session ID': s.sessionId,
 			Label: s.label || '-',
 			Status: s.status,
 			Mode: s.mode,
+			Owner: s.owner?.name ?? s.owner?.userId ?? '-',
 			Observers: String(s.observerCount),
 			Agents: String(s.subAgentCount),
 			Tasks: String(s.taskCount),
@@ -155,6 +94,7 @@ export const listSubcommand = createSubcommand({
 			{ name: 'Label', alignment: 'left' },
 			{ name: 'Status', alignment: 'center' },
 			{ name: 'Mode', alignment: 'center' },
+			{ name: 'Owner', alignment: 'left' },
 			{ name: 'Observers', alignment: 'right' },
 			{ name: 'Agents', alignment: 'right' },
 			{ name: 'Tasks', alignment: 'right' },

package/src/cmd/coder/loop.ts

@@ -0,0 +1,85 @@
+import { z } from 'zod';
+import { CoderClient } from '@agentuity/core/coder';
+import { ValidationOutputError } from '@agentuity/core';
+import { createSubcommand } from '../../types';
+import * as tui from '../../tui';
+import { getCommand } from '../../command-prefix';
+import { ErrorCode } from '../../errors';
+
+export const loopSubcommand = createSubcommand({
+	name: 'loop',
+	description: 'Get loop-mode state for a Coder Hub session',
+	tags: ['read-only', 'fast', 'requires-auth'],
+	idempotent: true,
+	requires: { auth: true, org: true },
+	examples: [
+		{
+			command: getCommand('coder loop codesess_abc123'),
+			description: 'Show loop state for a session',
+		},
+		{
+			command: getCommand('coder loop codesess_abc123 --json'),
+			description: 'Get loop state as JSON',
+		},
+	],
+	schema: {
+		args: z.object({
+			sessionId: z.string().describe('Session ID to inspect loop state for'),
+		}),
+		options: z.object({
+			url: z.string().optional().describe('Coder API URL override'),
+		}),
+	},
+	async handler(ctx) {
+		const { args, opts, options } = ctx;
+		const client = new CoderClient({
+			apiKey: ctx.auth.apiKey,
+			url: opts?.url,
+			orgId: ctx.orgId,
+		});
+
+		try {
+			const state = await client.getLoopState(args.sessionId);
+
+			if (options.json) {
+				return state;
+			}
+
+			const rows: Array<{ Field: string; Value: string }> = [
+				{ Field: 'Session ID', Value: state.sessionId },
+				{ Field: 'Workflow Mode', Value: state.workflowMode },
+			];
+
+			if (!state.loop) {
+				rows.push({ Field: 'Loop Status', Value: 'not active' });
+			} else {
+				rows.push({ Field: 'Loop Status', Value: state.loop.status });
+				rows.push({ Field: 'Iteration', Value: String(state.loop.iteration) });
+				rows.push({
+					Field: 'Max Iterations',
+					Value: String(state.loop.maxIterations ?? '-'),
+				});
+				rows.push({ Field: 'Goal', Value: state.loop.goal ?? '-' });
+				rows.push({ Field: 'Summary', Value: state.loop.summary ?? '-' });
+				rows.push({ Field: 'Next Action', Value: state.loop.nextAction ?? '-' });
+			}
+
+			tui.table(rows, [
+				{ name: 'Field', alignment: 'left' },
+				{ name: 'Value', alignment: 'left' },
+			]);
+
+			return state;
+		} catch (err) {
+			if (err instanceof ValidationOutputError) {
+				ctx.logger.trace('Validation response URL: %s', err.url ?? 'unknown');
+				ctx.logger.trace('Validation issues: %s', JSON.stringify(err.issues, null, 2));
+			}
+			const msg = err instanceof Error ? err.message : String(err);
+			tui.fatal(
+				`Failed to get loop state for ${args.sessionId}: ${msg}`,
+				ErrorCode.NETWORK_ERROR
+			);
+		}
+	},
+});

package/src/cmd/coder/participants.ts

@@ -0,0 +1,100 @@
+import { z } from 'zod';
+import { CoderClient } from '@agentuity/core/coder';
+import { ValidationOutputError } from '@agentuity/core';
+import { createSubcommand } from '../../types';
+import * as tui from '../../tui';
+import { getCommand } from '../../command-prefix';
+import { ErrorCode } from '../../errors';
+
+function formatRelativeTime(isoDate: string): string {
+	const parsed = new Date(isoDate).getTime();
+	if (Number.isNaN(parsed)) return 'unknown';
+	const diffMs = Math.max(0, Date.now() - parsed);
+	const seconds = Math.floor(diffMs / 1000);
+	if (seconds < 60) return `${seconds}s ago`;
+	const minutes = Math.floor(seconds / 60);
+	if (minutes < 60) return `${minutes}m ago`;
+	const hours = Math.floor(minutes / 60);
+	if (hours < 24) return `${hours}h ago`;
+	const days = Math.floor(hours / 24);
+	return `${days}d ago`;
+}
+
+export const participantsSubcommand = createSubcommand({
+	name: 'participants',
+	aliases: ['participant', 'members'],
+	description: 'List participants for a Coder Hub session',
+	tags: ['read-only', 'fast', 'requires-auth'],
+	idempotent: true,
+	requires: { auth: true, org: true },
+	examples: [
+		{
+			command: getCommand('coder participants codesess_abc123'),
+			description: 'List session participants',
+		},
+		{
+			command: getCommand('coder participants codesess_abc123 --json'),
+			description: 'Get session participants as JSON',
+		},
+	],
+	schema: {
+		args: z.object({
+			sessionId: z.string().describe('Session ID to list participants for'),
+		}),
+		options: z.object({
+			url: z.string().optional().describe('Coder API URL override'),
+		}),
+	},
+	async handler(ctx) {
+		const { args, opts, options } = ctx;
+		const client = new CoderClient({
+			apiKey: ctx.auth.apiKey,
+			url: opts?.url,
+			orgId: ctx.orgId,
+		});
+
+		try {
+			const data = await client.listParticipants(args.sessionId);
+
+			if (options.json) {
+				return data;
+			}
+
+			if (data.participants.length === 0) {
+				tui.info(`No participants found for session ${args.sessionId}.`);
+				return data;
+			}
+
+			tui.table(
+				data.participants.map((p) => ({
+					ID: p.id,
+					Role: p.role,
+					'Agent Role': p.agentRole ?? '-',
+					Transport: p.transport ?? '-',
+					Connected: p.connectedAt ? formatRelativeTime(p.connectedAt) : '-',
+					'Last Activity': p.lastActivityAt ? formatRelativeTime(p.lastActivityAt) : '-',
+				})),
+				[
+					{ name: 'ID', alignment: 'left' },
+					{ name: 'Role', alignment: 'left' },
+					{ name: 'Agent Role', alignment: 'left' },
+					{ name: 'Transport', alignment: 'center' },
+					{ name: 'Connected', alignment: 'right' },
+					{ name: 'Last Activity', alignment: 'right' },
+				]
+			);
+
+			return data;
+		} catch (err) {
+			if (err instanceof ValidationOutputError) {
+				ctx.logger.trace('Validation response URL: %s', err.url ?? 'unknown');
+				ctx.logger.trace('Validation issues: %s', JSON.stringify(err.issues, null, 2));
+			}
+			const msg = err instanceof Error ? err.message : String(err);
+			tui.fatal(
+				`Failed to list participants for session ${args.sessionId}: ${msg}`,
+				ErrorCode.NETWORK_ERROR
+			);
+		}
+	},
+});