@agentuity/cli 2.0.7 → 2.0.8

package/src/cmd/coder/archive.ts

@@ -0,0 +1,59 @@
+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 archiveSubcommand = createSubcommand({
+	name: 'archive',
+	description: 'Archive a Coder Hub session',
+	tags: ['mutating', 'requires-auth'],
+	requires: { auth: true, org: true },
+	examples: [
+		{
+			command: getCommand('coder archive codesess_abc123'),
+			description: 'Archive a session',
+		},
+		{
+			command: getCommand('coder archive codesess_abc123 --json'),
+			description: 'Archive a session and return JSON output',
+		},
+	],
+	schema: {
+		args: z.object({
+			sessionId: z.string().describe('Session ID to archive'),
+		}),
+		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 session = await client.archiveSession(args.sessionId);
+			const result = session ?? { archived: true, sessionId: args.sessionId };
+
+			if (options.json) {
+				return result;
+			}
+
+			tui.success(`Session ${args.sessionId} archived.`);
+			return result;
+		} 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 archive session ${args.sessionId}: ${msg}`, ErrorCode.NETWORK_ERROR);
+		}
+	},
+});

package/src/cmd/coder/create.ts

@@ -0,0 +1,268 @@
+import { z } from 'zod';
+import {
+	CoderClient,
+	type CoderCreateSessionRequest,
+	normalizeVisibility,
+} from '@agentuity/core/coder';
+import { ValidationOutputError } from '@agentuity/core';
+import { toCoderHubWsUrl } from '../../coder-hub-url';
+import { createSubcommand } from '../../types';
+import * as tui from '../../tui';
+import { getCommand } from '../../command-prefix';
+import { ErrorCode } from '../../errors';
+import { resolveExtensionPath, resolveExtensionRuntimeModulePath } from './extension-path';
+import { resolveGitHubRepo } from './resolve-repo';
+
+export const createCoderSubcommand = createSubcommand({
+	name: 'create',
+	aliases: ['new'],
+	description: 'Create a new Coder session',
+	tags: ['mutating', 'requires-auth'],
+	requires: { auth: true, org: true },
+	examples: [
+		{
+			command: getCommand('coder create "Build a REST API"'),
+			description: 'Create a simple session',
+		},
+		{
+			command: getCommand('coder create "Fix the login bug" --repo https://github.com/org/repo'),
+			description: 'Create with a repo',
+		},
+		{
+			command: getCommand('coder create "Refactor auth" --connect'),
+			description: 'Create and attach TUI',
+		},
+		{
+			command: getCommand(
+				'coder create "Build feature" --workflow-mode loop --loop-goal "Complete implementation" --loop-max-iterations 20'
+			),
+			description: 'Create a loop session',
+		},
+		{
+			command: getCommand(
+				'coder create "Quick task" --label "My Task" --tags frontend,urgent --json'
+			),
+			description: 'Create with label and tags, return JSON',
+		},
+	],
+	schema: {
+		args: z.object({
+			task: z.string().describe('Task prompt for the session'),
+		}),
+		options: z.object({
+			// Connection
+			url: z.string().optional().describe('Coder API URL override'),
+			connect: z.boolean().optional().describe('Connect to the session after creation'),
+			extension: z
+				.string()
+				.optional()
+				.describe('Coder extension path override (used with --connect)'),
+
+			// Session config
+			label: z.string().optional().describe('Human-readable session label'),
+			agent: z.string().optional().describe('Default agent role (e.g. lead, scout)'),
+			visibility: z
+				.string()
+				.optional()
+				.describe('Session visibility: private, org, or collaborate'),
+
+			// Workflow
+			workflowMode: z.string().optional().describe('Workflow mode: standard or loop'),
+			loopGoal: z.string().optional().describe('Goal for loop mode execution'),
+			loopMaxIterations: z.number().optional().describe('Maximum loop iterations'),
+			loopAutoContinue: z
+				.boolean()
+				.optional()
+				.describe('Auto-continue loop without manual approval'),
+			loopAllowDetached: z
+				.boolean()
+				.optional()
+				.describe('Allow loop to continue when no client attached'),
+
+			// Repository
+			repo: z.string().optional().describe('Git repository URL to clone'),
+			repoBranch: z.string().optional().describe('Branch to checkout for the repository'),
+
+			// Resources
+			workspaceId: z.string().optional().describe('Workspace ID to use'),
+			tags: z.string().optional().describe('Comma-separated tags'),
+			env: z
+				.string()
+				.optional()
+				.describe('Environment variables as KEY=VALUE pairs, comma-separated'),
+
+			// Skills (by ID for now)
+			savedSkillIds: z.string().optional().describe('Comma-separated saved skill IDs'),
+			skillBucketIds: z.string().optional().describe('Comma-separated skill bucket IDs'),
+		}),
+	},
+	async handler(ctx) {
+		const { args, opts, options } = ctx;
+		const client = new CoderClient({
+			apiKey: ctx.auth.apiKey,
+			url: opts?.url,
+			orgId: ctx.orgId,
+		});
+
+		// Build the create session request body from flags
+		const body: CoderCreateSessionRequest = {
+			task: args.task,
+			...(opts?.label && { label: opts.label }),
+			...(opts?.agent && { agent: opts.agent }),
+			...(opts?.visibility && { visibility: normalizeVisibility(opts.visibility) }),
+			...(opts?.workflowMode && { workflowMode: opts.workflowMode as 'standard' | 'loop' }),
+		};
+
+		// Build loop config if any loop option is set
+		if (
+			opts?.loopGoal ||
+			opts?.loopMaxIterations ||
+			opts?.loopAutoContinue !== undefined ||
+			opts?.loopAllowDetached !== undefined
+		) {
+			body.loop = {};
+			if (opts?.loopGoal) body.loop.goal = opts.loopGoal;
+			if (opts?.loopMaxIterations) body.loop.maxIterations = opts.loopMaxIterations;
+			if (opts?.loopAutoContinue !== undefined) body.loop.autoContinue = opts.loopAutoContinue;
+			if (opts?.loopAllowDetached !== undefined)
+				body.loop.allowDetached = opts.loopAllowDetached;
+			// Auto-set workflowMode to loop if loop options provided
+			if (!body.workflowMode) body.workflowMode = 'loop';
+		}
+
+		// Parse repo
+		if (opts?.repo) {
+			if (!options.json) tui.output('Resolving repository...');
+			try {
+				const resolved = await resolveGitHubRepo(client, opts.repo, opts?.repoBranch);
+				body.repo = resolved;
+			} catch (err) {
+				const msg = err instanceof Error ? err.message : String(err);
+				tui.fatal(`Failed to resolve repository: ${msg}`, ErrorCode.VALIDATION_FAILED);
+				return;
+			}
+		}
+
+		// Parse comma-separated values
+		if (opts?.tags)
+			body.tags = opts.tags
+				.split(',')
+				.map((t) => t.trim())
+				.filter(Boolean);
+		if (opts?.savedSkillIds)
+			body.savedSkillIds = opts.savedSkillIds
+				.split(',')
+				.map((s) => s.trim())
+				.filter(Boolean);
+		if (opts?.skillBucketIds)
+			body.skillBucketIds = opts.skillBucketIds
+				.split(',')
+				.map((s) => s.trim())
+				.filter(Boolean);
+
+		// Parse env vars: KEY=VALUE,KEY2=VALUE2
+		if (opts?.env) {
+			body.env = {};
+			for (const pair of opts.env.split(',')) {
+				const eq = pair.indexOf('=');
+				if (eq > 0) {
+					body.env[pair.slice(0, eq).trim()] = pair.slice(eq + 1).trim();
+				}
+			}
+		}
+
+		if (opts?.workspaceId) body.workspaceId = opts.workspaceId;
+
+		// Create the session
+		try {
+			const created = await client.createSession(body);
+
+			// JSON mode: return result and stop
+			if (options.json) {
+				return created;
+			}
+
+			tui.success(`Session ${created.sessionId} created (status: ${created.status})`);
+
+			// If --connect, wait for provisioning then attach TUI
+			if (opts?.connect) {
+				tui.output('Waiting for session to provision...');
+
+				// Poll until session is active
+				let status = created.status;
+				const startTime = Date.now();
+				const POLL_TIMEOUT = 120_000;
+				const POLL_INTERVAL = 3_000;
+
+				while (Date.now() - startTime < POLL_TIMEOUT) {
+					if (status !== 'creating' && status !== 'provisioning') break;
+					await new Promise((r) => setTimeout(r, POLL_INTERVAL));
+					try {
+						const detail = await client.getSession(created.sessionId);
+						status = detail.status;
+					} catch {
+						// Network blip — keep polling
+					}
+				}
+
+				if (status !== 'active') {
+					tui.fatal(
+						`Session did not become active (status: ${status})`,
+						ErrorCode.NETWORK_ERROR
+					);
+					return;
+				}
+
+				// Resolve extension and WS URL, then launch TUI
+				const hubHttpUrl = await client.getUrl();
+				const hubWsUrl = toCoderHubWsUrl(hubHttpUrl);
+
+				const extensionPath = await resolveExtensionPath(opts?.extension);
+				if (!extensionPath) {
+					tui.fatal(
+						'Could not find the Agentuity Coder extension.\n\nTry:\n  - Reinstall or update @agentuity/cli\n  - Install it locally: npm install @agentuity/coder-tui\n  - Set AGENTUITY_CODER_EXTENSION environment variable\n  - Pass --extension flag',
+						ErrorCode.CONFIG_INVALID
+					);
+					return;
+				}
+
+				const remoteTuiPath = await resolveExtensionRuntimeModulePath(extensionPath);
+				if (!remoteTuiPath) {
+					tui.fatal(
+						`Coder extension at ${extensionPath} is missing the remote TUI entrypoint`,
+						ErrorCode.CONFIG_INVALID
+					);
+					return;
+				}
+
+				if (!options.json) {
+					tui.newline();
+					tui.output(`  Hub:       ${tui.bold(hubWsUrl)}`);
+					tui.output(`  Extension: ${tui.bold(extensionPath)}`);
+					tui.output(`  Session:   ${tui.bold(created.sessionId)}`);
+					tui.newline();
+				}
+
+				try {
+					const { runRemoteTui } = await import(remoteTuiPath);
+					await runRemoteTui({
+						hubWsUrl,
+						sessionId: created.sessionId,
+						apiKey: ctx.auth.apiKey,
+						orgId: ctx.orgId,
+					});
+				} catch (err) {
+					const msg = err instanceof Error ? err.message : String(err);
+					tui.fatal(`Remote TUI failed: ${msg}`, ErrorCode.NETWORK_ERROR);
+				}
+			}
+		} 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 create Coder session: ${msg}`, ErrorCode.NETWORK_ERROR);
+		}
+	},
+});

package/src/cmd/coder/delete.ts

@@ -0,0 +1,67 @@
+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 deleteSubcommand = createSubcommand({
+	name: 'delete',
+	aliases: ['rm', 'del', 'remove'],
+	description: 'Delete a Coder Hub session',
+	tags: ['destructive', 'deletes-resource', 'requires-auth'],
+	requires: { auth: true, org: true },
+	examples: [
+		{
+			command: getCommand('coder delete codesess_abc123'),
+			description: 'Delete a session',
+		},
+		{
+			command: getCommand('coder delete codesess_abc123 --json'),
+			description: 'Delete a session and return JSON output',
+		},
+	],
+	schema: {
+		args: z.object({
+			sessionId: z.string().describe('Session ID to delete'),
+		}),
+		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,
+		});
+
+		if (!options.json) {
+			const confirmed = await tui.confirm(`Delete session ${args.sessionId}?`, false);
+			if (!confirmed) {
+				tui.info('Cancelled.');
+				return { deleted: false, sessionId: args.sessionId };
+			}
+		}
+
+		try {
+			await client.deleteSession(args.sessionId);
+		} 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 delete session ${args.sessionId}: ${msg}`, ErrorCode.NETWORK_ERROR);
+		}
+
+		if (options.json) {
+			return { deleted: true, sessionId: args.sessionId };
+		}
+
+		tui.success(`Session ${args.sessionId} deleted.`);
+		return { deleted: true, sessionId: args.sessionId };
+	},
+});

package/src/cmd/coder/events.ts

@@ -0,0 +1,106 @@
+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 eventsSubcommand = createSubcommand({
+	name: 'events',
+	aliases: ['event', 'ev'],
+	description: 'List event history for a Coder Hub session',
+	tags: ['read-only', 'requires-auth'],
+	idempotent: true,
+	requires: { auth: true, org: true },
+	examples: [
+		{
+			command: getCommand('coder events codesess_abc123'),
+			description: 'List recent session events',
+		},
+		{
+			command: getCommand('coder events codesess_abc123 --limit 100 --json'),
+			description: 'Get session event history as JSON',
+		},
+	],
+	schema: {
+		args: z.object({
+			sessionId: z.string().describe('Session ID to list events for'),
+		}),
+		options: z.object({
+			limit: z
+				.number()
+				.int()
+				.positive()
+				.optional()
+				.describe('Maximum number of events to return'),
+			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.listEventHistory(args.sessionId, {
+				limit: opts?.limit ?? 50,
+			});
+
+			if (options.json) {
+				return data;
+			}
+
+			if (data.events.length === 0) {
+				tui.info(`No events found for session ${args.sessionId}.`);
+				return data;
+			}
+
+			tui.table(
+				data.events.map((e) => ({
+					Event: e.event,
+					Category: e.category ?? '-',
+					Agent: e.agent ?? '-',
+					'Task ID': e.taskId ?? '-',
+					Occurred: e.occurredAt ? formatRelativeTime(e.occurredAt) : '-',
+				})),
+				[
+					{ name: 'Event', alignment: 'left' },
+					{ name: 'Category', alignment: 'left' },
+					{ name: 'Agent', alignment: 'left' },
+					{ name: 'Task ID', alignment: 'left' },
+					{ name: 'Occurred', 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 event history for session ${args.sessionId}: ${msg}`,
+				ErrorCode.NETWORK_ERROR
+			);
+		}
+	},
+});

package/src/cmd/coder/extension-path.ts

@@ -0,0 +1,71 @@
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+export type ExtensionPathResolverOptions = {
+	cwd?: string;
+	env?: NodeJS.ProcessEnv;
+	moduleUrl?: string;
+};
+
+export async function resolveExtensionPath(
+	flagPath?: string,
+	options: ExtensionPathResolverOptions = {}
+): Promise<string | null> {
+	const cwd = options.cwd ?? process.cwd();
+	const env = options.env ?? process.env;
+	const moduleUrl = options.moduleUrl ?? import.meta.url;
+
+	// 1. Explicit flag
+	if (flagPath) {
+		return resolve(cwd, flagPath);
+	}
+
+	// 2. Env var
+	const envPath = env.AGENTUITY_CODER_EXTENSION;
+	if (envPath) {
+		return resolve(cwd, envPath);
+	}
+
+	// 3. Bundled with CLI package (require.resolve)
+	try {
+		const cliDir = fileURLToPath(new URL('.', moduleUrl));
+		const entryPath = require.resolve('@agentuity/coder-tui', { paths: [cliDir] });
+		let dir = dirname(entryPath);
+		while (dir !== dirname(dir)) {
+			if (await Bun.file(resolve(dir, 'package.json')).exists()) return dir;
+			dir = dirname(dir);
+		}
+	} catch {
+		// require.resolve may fail in workspace/worktree setups — fall through to direct lookup
+	}
+
+	// 4. Direct node_modules lookup (workspace symlink fallback)
+	try {
+		const cliDir = fileURLToPath(new URL('.', moduleUrl));
+		// Walk up from this file to the CLI package root, then check node_modules
+		let dir = cliDir;
+		for (let i = 0; i < 10; i++) {
+			const candidate = resolve(dir, 'node_modules', '@agentuity', 'coder-tui');
+			if (await Bun.file(resolve(candidate, 'package.json')).exists()) return candidate;
+			const parent = dirname(dir);
+			if (parent === dir) break;
+			dir = parent;
+		}
+	} catch {
+		// ignore
+	}
+
+	return null;
+}
+
+export async function resolveExtensionRuntimeModulePath(
+	extensionPath: string
+): Promise<string | null> {
+	const sourceModulePath = resolve(extensionPath, 'src', 'remote-tui.ts');
+	if (await Bun.file(sourceModulePath).exists()) return sourceModulePath;
+
+	const distModulePath = resolve(extensionPath, 'dist', 'remote-tui.js');
+	if (await Bun.file(distModulePath).exists()) return distModulePath;
+
+	return null;
+}