@agentuity/cli 2.0.6 → 2.0.8

package/src/cmd/coder/workspace/create.ts

@@ -0,0 +1,104 @@
+import { z } from 'zod';
+import { CoderClient, type CoderCreateWorkspaceRequest } 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 { resolveGitHubRepo } from '../resolve-repo';
+
+export const createWorkspaceSubcommand = createSubcommand({
+	name: 'create',
+	aliases: ['new', 'add'],
+	description: 'Create a new Coder workspace',
+	tags: ['mutating', 'requires-auth'],
+	requires: { auth: true, org: true },
+	examples: [
+		{
+			command: getCommand('coder workspace create "My Workspace"'),
+			description: 'Create a workspace with a name',
+		},
+		{
+			command: getCommand(
+				'coder workspace create "My Workspace" --description "For frontend work" --scope org'
+			),
+			description: 'Create an org-scoped workspace with description',
+		},
+		{
+			command: getCommand(
+				'coder workspace create "My Workspace" --repo https://github.com/org/repo --repo-branch main'
+			),
+			description: 'Create a workspace with a repository',
+		},
+		{
+			command: getCommand('coder workspace create "My Workspace" --json'),
+			description: 'Create a workspace and return JSON output',
+		},
+	],
+	schema: {
+		args: z.object({
+			name: z.string().describe('Workspace name'),
+		}),
+		options: z.object({
+			url: z.string().optional().describe('Coder API URL override'),
+			description: z.string().optional().describe('Workspace description'),
+			scope: z.string().optional().describe('Workspace scope: user or org'),
+			repo: z.string().optional().describe('Repository URL to add'),
+			repoBranch: z.string().optional().describe('Branch for the repository'),
+		}),
+	},
+	async handler(ctx) {
+		const { args, opts, options } = ctx;
+		const client = new CoderClient({
+			apiKey: ctx.auth.apiKey,
+			url: opts?.url,
+			orgId: ctx.orgId,
+		});
+
+		const body: CoderCreateWorkspaceRequest = {
+			name: args.name,
+			...(opts?.description && { description: opts.description }),
+			...(opts?.scope && { scope: opts.scope as 'user' | 'org' }),
+		};
+
+		if (opts?.repo) {
+			if (!options.json) tui.output('Resolving repository...');
+			try {
+				const resolved = await resolveGitHubRepo(client, opts.repo, opts?.repoBranch);
+				body.repos = [resolved];
+			} catch (err) {
+				const msg = err instanceof Error ? err.message : String(err);
+				tui.fatal(`Failed to resolve repository: ${msg}`, ErrorCode.VALIDATION_FAILED);
+				return;
+			}
+		}
+
+		try {
+			const created = await client.createWorkspace(body);
+
+			if (options.json) {
+				return created;
+			}
+
+			tui.success(`Workspace ${created.id} created.`);
+			tui.newline();
+			tui.output(`  Name:        ${tui.bold(created.name)}`);
+			if (created.description) {
+				tui.output(`  Description: ${created.description}`);
+			}
+			tui.output(`  Scope:       ${created.scope}`);
+			tui.output(`  Repos:       ${created.repoCount}`);
+			tui.output(`  Skills:      ${created.selectionCount}`);
+
+			return created;
+		} 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));
+				tui.fatal(`Failed to create workspace: ${err.message}`, ErrorCode.VALIDATION_FAILED);
+			}
+			const msg = err instanceof Error ? err.message : String(err);
+			tui.fatal(`Failed to create workspace: ${msg}`, ErrorCode.NETWORK_ERROR);
+		}
+	},
+});

package/src/cmd/coder/workspace/delete.ts

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

package/src/cmd/coder/workspace/get.ts

@@ -0,0 +1,112 @@
+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 getWorkspaceSubcommand = createSubcommand({
+	name: 'get',
+	aliases: ['show', 'inspect'],
+	description: 'Show detailed information about a Coder workspace',
+	tags: ['read-only', 'fast', 'requires-auth'],
+	idempotent: true,
+	requires: { auth: true, org: true },
+	examples: [
+		{
+			command: getCommand('coder workspace get ws_abc123'),
+			description: 'Get a workspace by ID',
+		},
+		{
+			command: getCommand('coder workspace get ws_abc123 --json'),
+			description: 'Get workspace details as JSON',
+		},
+	],
+	schema: {
+		args: z.object({
+			workspaceId: z.string().describe('Workspace ID to inspect'),
+		}),
+		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 workspace = await client.getWorkspace(args.workspaceId);
+
+			if (options.json) {
+				return workspace;
+			}
+
+			tui.header(`Workspace: ${workspace.name}`);
+			tui.newline();
+			tui.output(`  ID:          ${workspace.id}`);
+			tui.output(`  Name:        ${tui.bold(workspace.name)}`);
+			if (workspace.description) {
+				tui.output(`  Description: ${workspace.description}`);
+			}
+			tui.output(`  Scope:       ${workspace.scope}`);
+			tui.output(`  Owner:       ${workspace.ownerUserId}`);
+			tui.output(`  Created:     ${formatRelativeTime(workspace.createdAt)}`);
+			tui.output(`  Updated:     ${formatRelativeTime(workspace.updatedAt)}`);
+			tui.newline();
+
+			if (workspace.repos.length > 0) {
+				tui.output(`  Repositories (${workspace.repoCount}):`);
+				for (const repo of workspace.repos) {
+					const name = repo.fullName || repo.name || repo.url || repo.cloneUrl || 'unknown';
+					const branch = repo.branch || repo.defaultBranch || '';
+					tui.output(`    - ${name}${branch ? ` (${branch})` : ''}`);
+				}
+				tui.newline();
+			}
+
+			if (workspace.savedSkillIds.length > 0) {
+				tui.output(`  Saved Skill IDs (${workspace.savedSkillIds.length}):`);
+				for (const id of workspace.savedSkillIds) {
+					tui.output(`    - ${id}`);
+				}
+				tui.newline();
+			}
+
+			if (workspace.skillBucketIds.length > 0) {
+				tui.output(`  Skill Bucket IDs (${workspace.skillBucketIds.length}):`);
+				for (const id of workspace.skillBucketIds) {
+					tui.output(`    - ${id}`);
+				}
+				tui.newline();
+			}
+
+			return workspace;
+		} 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 workspace ${args.workspaceId}: ${msg}`, ErrorCode.NETWORK_ERROR);
+		}
+	},
+});

package/src/cmd/coder/workspace/index.ts

@@ -0,0 +1,38 @@
+import { createCommand } from '../../../types';
+import { listSubcommand } from './list';
+import { createWorkspaceSubcommand } from './create';
+import { getWorkspaceSubcommand } from './get';
+import { deleteWorkspaceSubcommand } from './delete';
+import { getCommand } from '../../../command-prefix';
+
+export const workspaceCommand = createCommand({
+	name: 'workspace',
+	aliases: ['workspaces', 'ws'],
+	description: 'Manage Coder workspaces',
+	tags: ['requires-auth'],
+	requires: { auth: true, org: true },
+	examples: [
+		{
+			command: getCommand('coder workspace list'),
+			description: 'List all workspaces',
+		},
+		{
+			command: getCommand('coder workspace create "My Workspace"'),
+			description: 'Create a new workspace',
+		},
+		{
+			command: getCommand('coder workspace get ws_abc123'),
+			description: 'Show workspace details',
+		},
+		{
+			command: getCommand('coder workspace delete ws_abc123'),
+			description: 'Delete a workspace',
+		},
+	],
+	subcommands: [
+		listSubcommand,
+		createWorkspaceSubcommand,
+		getWorkspaceSubcommand,
+		deleteWorkspaceSubcommand,
+	],
+});

package/src/cmd/coder/workspace/list.ts

@@ -0,0 +1,101 @@
+import { z } from 'zod';
+import {
+	CoderClient,
+	type CoderWorkspaceDetail,
+	CoderWorkspaceDetailSchema,
+} 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 listSubcommand = createSubcommand({
+	name: 'list',
+	aliases: ['ls'],
+	description: 'List Coder workspaces',
+	tags: ['read-only', 'fast', 'requires-auth'],
+	idempotent: true,
+	requires: { auth: true, org: true },
+	examples: [
+		{
+			command: getCommand('coder workspace list'),
+			description: 'List Coder workspaces',
+		},
+		{
+			command: getCommand('coder workspace list --json'),
+			description: 'Return workspaces as JSON',
+		},
+	],
+	schema: {
+		options: z.object({
+			url: z.string().optional().describe('Coder API URL override'),
+		}),
+		response: z.array(CoderWorkspaceDetailSchema),
+	},
+	async handler(ctx) {
+		const { options, opts } = ctx;
+		const client = new CoderClient({
+			apiKey: ctx.auth.apiKey,
+			url: opts?.url,
+			orgId: ctx.orgId,
+		});
+
+		let workspaces: CoderWorkspaceDetail[] = [];
+		try {
+			const response = await client.listWorkspaces();
+			workspaces = response.workspaces;
+		} 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 Coder workspaces: ${msg}`, ErrorCode.NETWORK_ERROR);
+		}
+
+		if (options.json) {
+			return workspaces;
+		}
+
+		if (workspaces.length === 0) {
+			tui.info('No Coder workspaces found.');
+			return [];
+		}
+
+		tui.table(
+			workspaces.map((w) => ({
+				ID: w.id,
+				Name: w.name,
+				Scope: w.scope,
+				Repos: String(w.repoCount),
+				Skills: String(w.selectionCount),
+				Created: formatRelativeTime(w.createdAt),
+			})),
+			[
+				{ name: 'ID', alignment: 'left' },
+				{ name: 'Name', alignment: 'left' },
+				{ name: 'Scope', alignment: 'center' },
+				{ name: 'Repos', alignment: 'right' },
+				{ name: 'Skills', alignment: 'right' },
+				{ name: 'Created', alignment: 'right' },
+			]
+		);
+
+		return workspaces;
+	},
+});

package/src/cmd/dev/sync.ts

@@ -169,7 +169,7 @@ class DevmodeSyncService implements IDevmodeSyncService {
 					}
 				}
 			}
-			this.logger.debug('Previous metadata found with %d eval(s)', prevEvalCount);
+			this.logger.debug('Previous metadata found with %d evaluations', prevEvalCount);
 		} else {
 			this.logger.debug('No previous metadata, all evals will be treated as new');
 		}
@@ -182,7 +182,7 @@ class DevmodeSyncService implements IDevmodeSyncService {
 			if (agent.evals) {
 				currentEvalCount += agent.evals.length;
 				this.logger.debug(
-					'[CLI EVAL SYNC] Agent "%s" has %d eval(s)',
+					'[CLI EVAL SYNC] Agent "%s" has %d evaluations',
 					agent.name,
 					agent.evals.length
 				);
@@ -196,7 +196,7 @@ class DevmodeSyncService implements IDevmodeSyncService {
 				}
 			}
 		}
-		this.logger.debug('[CLI EVAL SYNC] Total current eval(s): %d', currentEvalCount);
+		this.logger.debug('[CLI EVAL SYNC] Total current evaluations: %d', currentEvalCount);
 
 		// Get agents and evals to sync using shared diff logic
 		const { create: agentsToCreate, delete: agentsToDelete } = getAgentsToSync(
@@ -241,7 +241,7 @@ class DevmodeSyncService implements IDevmodeSyncService {
 			}
 			if (evalsToCreate.length > 0 || evalsToDelete.length > 0) {
 				this.logger.debug(
-					'Successfully bulk synced %d eval(s) to create, %d eval(s) to delete',
+					'Successfully bulk synced %d evaluations to create, %d evaluations to delete',
 					evalsToCreate.length,
 					evalsToDelete.length
 				);
@@ -369,7 +369,7 @@ class MockDevmodeSyncService implements IDevmodeSyncService {
 
 		if (evalsToCreate.length > 0 || evalsToDelete.length > 0) {
 			this.logger.debug(
-				'[MOCK] Would make request: POST /cli/devmode/eval with %d eval(s) to create, %d eval(s) to delete',
+				'[MOCK] Would make request: POST /cli/devmode/eval with %d evaluations to create, %d evaluations to delete',
 				evalsToCreate.length,
 				evalsToDelete.length
 			);

package/src/coder-hub-url.ts

@@ -0,0 +1,32 @@
+export function normalizeCoderHubHttpUrl(url: string): string {
+	let normalized = url.trim().replace(/\/+$/, '');
+
+	if (normalized.startsWith('ws://')) normalized = 'http://' + normalized.slice(5);
+	else if (normalized.startsWith('wss://')) normalized = 'https://' + normalized.slice(6);
+
+	normalized = normalized.replace(/\/api\/ws\b.*$/, '');
+	normalized = normalized.replace(/\/ws\b.*$/, '');
+	normalized = normalized.replace(/\/api\/hub\b.*$/, '');
+
+	return normalized.replace(/\/+$/, '');
+}
+
+export function toCoderHubWsUrl(hubHttpUrl: string): string {
+	let wsUrl = hubHttpUrl;
+	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;
+}

package/src/config.ts

@@ -28,6 +28,14 @@ import { ConfigSchema, ProjectSchema } from './types';
 export const defaultProfileName = 'production';
 
 export function getDefaultConfigDir(): string {
+	const configDirOverride = process.env.AGENTUITY_CONFIG_DIR?.trim();
+	if (configDirOverride) {
+		if (configDirOverride.startsWith('~/')) {
+			return resolve(join(homedir(), configDirOverride.slice(2)));
+		}
+		return resolve(configDirOverride);
+	}
+
 	return join(homedir(), '.config', 'agentuity');
 }
 
@@ -144,16 +152,22 @@ let cachedConfig: Config | null | undefined;
 // Track the resolved config path so saveConfig writes back to the same file
 let cachedConfigPath: string | undefined;
 
+export function resetConfigCache(): void {
+	cachedConfig = undefined;
+	cachedConfigPath = undefined;
+}
+
 export async function loadConfig(
 	customPath?: string,
 	skipCache = false,
 	profileFromFlag?: string
 ): Promise<Config | null> {
-	// Use cache if available and not skipped
-	if (!skipCache && cachedConfig !== undefined) {
+	const configPath = customPath ? expandTilde(customPath) : await getProfile(profileFromFlag);
+
+	// Use cache if available and not skipped, but only if the path matches
+	if (!skipCache && cachedConfig !== undefined && cachedConfigPath === configPath) {
 		return cachedConfig;
 	}
-	const configPath = customPath ? expandTilde(customPath) : await getProfile(profileFromFlag);
 
 	try {
 		const file = Bun.file(configPath);

package/src/internal-logger.ts

@@ -43,6 +43,16 @@ const SENSITIVE_ENV_PATTERNS = [
 	/AUTH/i,
 ];
 
+const MASKED_ARG_VALUE = '***MASKED***';
+const SENSITIVE_ARG_PATTERNS = [
+	/^--?api[-_]?key$/i,
+	/^--?token$/i,
+	/^--?secret$/i,
+	/^--?password$/i,
+	/^--?client[-_]?secret$/i,
+	/^--?auth[-_]?value$/i,
+];
+
 interface SessionMetadata {
 	sessionId: string;
 	bucket: number;
@@ -102,6 +112,75 @@ function maskEnvironment(): Record<string, string> {
 	return masked;
 }
 
+function isSensitiveArgFlag(arg: string): boolean {
+	return SENSITIVE_ARG_PATTERNS.some((pattern) => pattern.test(arg));
+}
+
+function sanitizeArgsForLogging(args: string[]): string[] {
+	const sanitized: string[] = [];
+	let maskNextValue = false;
+
+	for (let i = 0; i < args.length; i += 1) {
+		const arg = args[i]!;
+
+		if (maskNextValue) {
+			if (!arg.startsWith('-')) {
+				sanitized.push(MASKED_ARG_VALUE);
+				maskNextValue = false;
+				continue;
+			}
+
+			sanitized.push(MASKED_ARG_VALUE);
+			maskNextValue = false;
+			i -= 1;
+			continue;
+		}
+
+		if (!arg.startsWith('-')) {
+			sanitized.push(arg);
+			continue;
+		}
+
+		const equalsIndex = arg.indexOf('=');
+		if (equalsIndex > 0) {
+			const flag = arg.slice(0, equalsIndex);
+			if (isSensitiveArgFlag(flag)) {
+				sanitized.push(`${flag}=${MASKED_ARG_VALUE}`);
+				continue;
+			}
+		}
+
+		sanitized.push(arg);
+		if (isSensitiveArgFlag(arg)) {
+			maskNextValue = true;
+		}
+	}
+
+	return sanitized;
+}
+
+export function sanitizeCliCommandForLogging(
+	command: string,
+	args: string[]
+): { command: string; args: string[] } {
+	const commandTokens = command ? command.split(' ') : [];
+
+	if (
+		commandTokens.length >= 5 &&
+		commandTokens[0] === 'coder' &&
+		commandTokens[1] === 'config' &&
+		commandTokens[2] === 'set' &&
+		commandTokens[3] === 'apikey'
+	) {
+		commandTokens[4] = MASKED_ARG_VALUE;
+	}
+
+	return {
+		command: commandTokens.join(' '),
+		args: sanitizeArgsForLogging(args),
+	};
+}
+
 /**
  * Get the logs directory path
  */
@@ -266,14 +345,16 @@ export class InternalLogger implements Logger {
 			// Use workingDir as cwd in session metadata
 			const cwd = workingDir;
 
+			const sanitizedInvocation = sanitizeCliCommandForLogging(command, args);
+
 			// Gather session metadata
 			const sessionMetadata: SessionMetadata = {
 				sessionId: this.sessionId,
 				bucket: this.bucket,
 				pid: process.pid,
 				ppid: process.ppid,
-				command,
-				args,
+				command: sanitizedInvocation.command,
+				args: sanitizedInvocation.args,
 				timestamp: new Date().toISOString(),
 				cli: {
 					version: this.cliVersion,