@agentuity/cli 0.1.14 → 0.1.16

package/src/auth.ts

@@ -104,8 +104,13 @@ export async function optionalAuth(
 		return auth;
 	}
 
-	// Skip interactive prompts if requested (e.g., --confirm flag in CI/scripts)
+	// Skip interactive prompts if requested (e.g., --confirm flag, --no-register in CI/scripts)
+	// Still show the logged out message to inform user about limited capabilities
 	if (skipPrompts) {
+		if (isTTY()) {
+			const hasLoggedIn = await hasLoggedInBefore();
+			tui.showLoggedOutMessage(getAppBaseURL(ctx.config ?? null), hasLoggedIn);
+		}
 		return null;
 	}
 
@@ -269,11 +274,7 @@ export async function optionalOrg(
 		return undefined;
 	}
 
-	// Skip org selection if --no-register is explicitly set (e.g., create command)
-	// Type assertion: register is a command-specific option not in GlobalOptions
-	if ('register' in options && (options as { register?: boolean }).register === false) {
-		return undefined;
-	}
+	// Note: --no-register check is handled in cli.ts before calling this function
 
 	// Check if org is provided via --org-id flag
 	if (options.orgId) {

package/src/cli.ts

@@ -973,6 +973,10 @@ async function registerSubcommand(
 					arrayDesc,
 					(value: string, previous: string[]) => (previous ?? []).concat([value])
 				);
+			} else if (opt.type === 'optionalString') {
+				// Optional string: --flag uses true, --flag=value uses the string value
+				// In Commander.js, [value] means optional argument
+				cmd.option(`${flagSpec} [${opt.name}]`, desc);
 			} else {
 				const strDefault = opt.hasDefault
 					? typeof opt.defaultValue === 'function'
@@ -1019,7 +1023,16 @@ async function registerSubcommand(
 				try {
 					const auth = await requireAuth(baseCtx);
 					if (auth) {
-						const apiClient = createAPIClient(baseCtx, baseCtx.config);
+						// Create config with auth credentials for API client
+						const configWithAuth = {
+							...baseCtx.config,
+							auth: {
+								api_key: auth.apiKey,
+								user_id: auth.userId,
+								expires: auth.expires.getTime(),
+							},
+						};
+						const apiClient = createAPIClient(baseCtx, configWithAuth as Config);
 						const { projectGet } = await import('@agentuity/server');
 						const projectDetails = await projectGet(apiClient, { id: projectId, mask: true });
 						project = {
@@ -1155,16 +1168,32 @@ async function registerSubcommand(
 							ctx as CommandContext & { apiClient: APIClientType }
 						);
 					}
-					if (normalized.optionalOrg && ctx.auth) {
+					// Skip org handling if --no-register is set (org only needed for registration)
+					const skipOrg =
+						normalized.optionalOrg &&
+						!normalized.requiresOrg &&
+						ctx.opts &&
+						(ctx.opts as Record<string, unknown>).register === false;
+
+					if (normalized.optionalOrg && ctx.auth && !skipOrg) {
 						ctx.orgId = await selectOptionalOrg(
 							ctx as CommandContext & { apiClient: APIClientType }
 						);
 					}
+					// Skip region handling if --no-register is set (region only needed for registration)
+					const skipRegion =
+						normalized.optionalRegion &&
+						!normalized.requiresRegion &&
+						!normalized.requiresRegions &&
+						ctx.opts &&
+						(ctx.opts as Record<string, unknown>).register === false;
+
 					if (
 						(normalized.requiresRegion ||
 							normalized.optionalRegion ||
 							normalized.requiresRegions) &&
-						ctx.apiClient
+						ctx.apiClient &&
+						!skipRegion
 					) {
 						const apiClient: APIClientType = ctx.apiClient as APIClientType;
 						const regions = await tui.spinner({
@@ -1241,16 +1270,32 @@ async function registerSubcommand(
 				if (normalized.requiresOrg) {
 					ctx.orgId = await requireOrg(ctx as CommandContext & { apiClient: APIClientType });
 				}
-				if (normalized.optionalOrg && ctx.auth) {
+				// Skip org handling if --no-register is set (org only needed for registration)
+				const skipOrg =
+					normalized.optionalOrg &&
+					!normalized.requiresOrg &&
+					ctx.opts &&
+					(ctx.opts as Record<string, unknown>).register === false;
+
+				if (normalized.optionalOrg && ctx.auth && !skipOrg) {
 					ctx.orgId = await selectOptionalOrg(
 						ctx as CommandContext & { apiClient: APIClientType }
 					);
 				}
+				// Skip region handling if --no-register is set (region only needed for registration)
+				const skipRegion =
+					normalized.optionalRegion &&
+					!normalized.requiresRegion &&
+					!normalized.requiresRegions &&
+					ctx.opts &&
+					(ctx.opts as Record<string, unknown>).register === false;
+
 				if (
 					(normalized.requiresRegion ||
 						normalized.optionalRegion ||
 						normalized.requiresRegions) &&
-					ctx.apiClient
+					ctx.apiClient &&
+					!skipRegion
 				) {
 					const apiClient: APIClientType = ctx.apiClient as APIClientType;
 					const regions = await tui.spinner({
@@ -1322,8 +1367,8 @@ async function registerSubcommand(
 				);
 			}
 
-			// Check if --confirm flag is set to skip interactive prompts
-			const skipPrompts = options.confirm === true;
+			// Check if --confirm flag or --no-register flag is set to skip interactive prompts
+			const skipPrompts = options.confirm === true || options.register === false;
 			const auth = await optionalAuth(
 				baseCtx as CommandContext<undefined>,
 				continueText,
@@ -1375,16 +1420,31 @@ async function registerSubcommand(
 							ctx as CommandContext & { apiClient: APIClientType }
 						);
 					}
-					if (normalized.optionalOrg && ctx.apiClient && auth) {
+					// Skip org handling if --no-register is set (org only needed for registration)
+					const skipOrg =
+						normalized.optionalOrg &&
+						!normalized.requiresOrg &&
+						ctx.opts &&
+						(ctx.opts as Record<string, unknown>).register === false;
+
+					if (normalized.optionalOrg && ctx.apiClient && auth && !skipOrg) {
 						ctx.orgId = await selectOptionalOrg(
 							ctx as CommandContext & { apiClient?: APIClientType; auth?: AuthData }
 						);
 						baseCtx.logger.trace('selected orgId: %s', ctx.orgId);
 					}
+					// Skip region handling if --no-register is set (region only needed for registration)
+					const skipRegion =
+						normalized.optionalRegion &&
+						!normalized.requiresRegion &&
+						ctx.opts &&
+						(ctx.opts as Record<string, unknown>).register === false;
+
 					if (
 						(normalized.requiresRegion || normalized.optionalRegion) &&
 						ctx.apiClient &&
-						auth
+						auth &&
+						!skipRegion
 					) {
 						const apiClient: APIClientType = ctx.apiClient as APIClientType;
 						const regions = await tui.spinner({
@@ -1455,12 +1515,25 @@ async function registerSubcommand(
 				if (normalized.requiresOrg && ctx.apiClient) {
 					ctx.orgId = await requireOrg(ctx as CommandContext & { apiClient: APIClientType });
 				}
-				if (normalized.optionalOrg && ctx.apiClient) {
+				// Skip org handling if --no-register is set (org only needed for registration)
+				// For non-schema commands, check options directly (Commander passes all options)
+				const skipOrg =
+					normalized.optionalOrg &&
+					!normalized.requiresOrg &&
+					(options as Record<string, unknown>).register === false;
+
+				if (normalized.optionalOrg && ctx.apiClient && !skipOrg) {
 					ctx.orgId = await selectOptionalOrg(
 						ctx as CommandContext & { apiClient?: APIClientType; auth?: AuthData }
 					);
 				}
-				if ((normalized.requiresRegion || normalized.optionalRegion) && ctx.apiClient) {
+				// Skip region handling if --no-register is set (region only needed for registration)
+				const skipRegion =
+					normalized.optionalRegion &&
+					!normalized.requiresRegion &&
+					(options as Record<string, unknown>).register === false;
+
+				if ((normalized.requiresRegion || normalized.optionalRegion) && ctx.apiClient && !skipRegion) {
 					const apiClient: APIClientType = ctx.apiClient as APIClientType;
 					const regions = await tui.spinner({
 						message: 'Fetching cloud regions',

package/src/cmd/ai/index.ts

@@ -3,6 +3,7 @@ import capabilitiesCommand from './capabilities';
 import promptCommand from './prompt';
 import schemaCommand from './schema';
 import skillsCommand from './skills';
+import opencodeCommand from './opencode';
 import { getCommand } from '../../command-prefix';
 
 export const command = createCommand({
@@ -11,6 +12,10 @@ export const command = createCommand({
 	skipUpgradeCheck: true,
 	tags: ['fast'],
 	examples: [
+		{
+			command: getCommand('ai opencode install'),
+			description: 'Install Agentuity Open Code plugin',
+		},
 		{
 			command: getCommand('ai capabilities show'),
 			description: 'Show CLI capabilities for AI agents',
@@ -24,5 +29,5 @@ export const command = createCommand({
 			description: 'Generate Agent Skills from CLI schema',
 		},
 	],
-	subcommands: [capabilitiesCommand, promptCommand, schemaCommand, skillsCommand],
+	subcommands: [opencodeCommand, capabilitiesCommand, promptCommand, schemaCommand, skillsCommand],
 });

package/src/cmd/ai/opencode/index.ts

@@ -0,0 +1,28 @@
+import { createCommand } from '../../../types';
+import { installSubcommand } from './install';
+import { uninstallSubcommand } from './uninstall';
+import { runSubcommand } from './run';
+import { getCommand } from '../../../command-prefix';
+
+export const command = createCommand({
+	name: 'opencode',
+	description: 'Agentuity Open Code plugin - AI coding agent team',
+	tags: ['fast'],
+	examples: [
+		{
+			command: getCommand('ai opencode install'),
+			description: 'Install Agentuity Open Code plugin',
+		},
+		{
+			command: getCommand('ai opencode uninstall'),
+			description: 'Uninstall Agentuity Open Code plugin',
+		},
+		{
+			command: getCommand('ai opencode run "implement dark mode"'),
+			description: 'Run a task with the Agentuity Coder agent team',
+		},
+	],
+	subcommands: [installSubcommand, uninstallSubcommand, runSubcommand],
+});
+
+export default command;

package/src/cmd/ai/opencode/install.ts

@@ -0,0 +1,120 @@
+import { mkdirSync, writeFileSync, readFileSync, existsSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { createSubcommand, type CommandContext } from '../../../types';
+import * as tui from '../../../tui';
+import { getCommand } from '../../../command-prefix';
+
+const OPENCODE_CONFIG_DIR = join(homedir(), '.config', 'opencode');
+const OPENCODE_CONFIG_FILE = join(OPENCODE_CONFIG_DIR, 'opencode.json');
+
+export const installSubcommand = createSubcommand({
+	name: 'install',
+	description: 'Install Agentuity Open Code plugin',
+	tags: ['fast'],
+	requires: { auth: true, apiClient: true, org: true },
+	examples: [
+		{
+			command: getCommand('ai opencode install'),
+			description: 'Install Agentuity Open Code plugin',
+		},
+	],
+	async handler(ctx: CommandContext<{ auth: true; apiClient: true; org: true }>) {
+		const { options, orgId } = ctx;
+		const jsonMode = !!options?.json;
+
+		if (!jsonMode) {
+			tui.newline();
+			tui.output(tui.bold('Installing Agentuity Open Code plugin'));
+			tui.newline();
+			tui.success(`Using organization: ${orgId}`);
+		}
+
+		const pluginEntry = '@agentuity/opencode';
+
+		// Update Open Code config if needed
+		let openCodeUpdated = false;
+		if (!existsSync(OPENCODE_CONFIG_DIR)) {
+			mkdirSync(OPENCODE_CONFIG_DIR, { recursive: true });
+		}
+
+		let openCodeConfig: { plugin?: string[]; $schema?: string } = {};
+		if (existsSync(OPENCODE_CONFIG_FILE)) {
+			try {
+				const content = readFileSync(OPENCODE_CONFIG_FILE, 'utf-8');
+				openCodeConfig = JSON.parse(content);
+			} catch {
+				openCodeConfig = {};
+			}
+		}
+
+		if (!openCodeConfig.plugin) {
+			openCodeConfig.plugin = [];
+		}
+
+		// Check if the exact plugin entry already exists
+		const hasExactEntry = openCodeConfig.plugin.includes(pluginEntry);
+
+		// Check if there's an existing entry that needs updating
+		const existingIndex = openCodeConfig.plugin.findIndex((p) => p === '@agentuity/opencode');
+
+		if (hasExactEntry) {
+			if (!jsonMode) {
+				tui.info('Open Code plugin already configured');
+			}
+		} else if (existingIndex >= 0) {
+			// Update existing entry to new value
+			openCodeConfig.plugin[existingIndex] = pluginEntry;
+			writeFileSync(OPENCODE_CONFIG_FILE, JSON.stringify(openCodeConfig, null, 2));
+			if (!jsonMode) {
+				tui.success(`Updated Open Code plugin to: ${pluginEntry}`);
+			}
+			openCodeUpdated = true;
+		} else {
+			// Add new entry
+			openCodeConfig.plugin.push(pluginEntry);
+			writeFileSync(OPENCODE_CONFIG_FILE, JSON.stringify(openCodeConfig, null, 2));
+			if (!jsonMode) {
+				tui.success(`Added ${pluginEntry} to Open Code config`);
+			}
+			openCodeUpdated = true;
+		}
+
+		// Summary (TUI only)
+		if (!jsonMode) {
+			tui.newline();
+			if (openCodeUpdated) {
+				tui.output(tui.bold('Agentuity Open Code plugin installed successfully!'));
+			} else {
+				tui.output(tui.bold('Agentuity Open Code plugin already installed'));
+			}
+
+			tui.newline();
+			tui.info('Next steps:');
+			tui.output(`  ${tui.ICONS.bullet} Start Open Code to use Agentuity Coder agents`);
+			tui.output(
+				`  ${tui.ICONS.bullet} Run ${tui.bold(getCommand('ai opencode run "<task>"'))} to execute tasks`
+			);
+			tui.newline();
+
+			tui.output(tui.muted('Recommended MCP servers for Scout/Expert agents:'));
+			tui.output(tui.muted(`Add to your opencode.json (${OPENCODE_CONFIG_FILE}):`));
+			tui.newline();
+			tui.output(tui.muted('  "mcp": {'));
+			tui.output(
+				tui.muted(
+					'    "context7": { "type": "remote", "url": "https://mcp.context7.com/mcp" },'
+				)
+			);
+			tui.output(
+				tui.muted('    "grep_app": { "type": "remote", "url": "https://mcp.grep.app" }')
+			);
+			tui.output(tui.muted('  }'));
+			tui.newline();
+		}
+
+		return { success: true, orgId };
+	},
+});
+
+export default installSubcommand;

package/src/cmd/ai/opencode/run.ts

@@ -0,0 +1,103 @@
+import { createSubcommand, type CommandContext } from '../../../types';
+import * as tui from '../../../tui';
+import { getCommand } from '../../../command-prefix';
+import { z } from 'zod';
+
+const RunArgsSchema = z.object({
+	task: z.string().describe('The task description to execute'),
+});
+
+const RunOptionsSchema = z.object({
+	sandbox: z.boolean().optional().describe('Run in a cloud sandbox environment'),
+	json: z.boolean().optional().describe('Output raw JSON events'),
+});
+
+export const runSubcommand = createSubcommand({
+	name: 'run',
+	description: 'Run a task with the Agentuity Coder agent team (non-interactive)',
+	tags: ['slow'],
+	requires: { auth: true },
+	schema: {
+		args: RunArgsSchema,
+		options: RunOptionsSchema,
+	},
+	examples: [
+		{
+			command: getCommand('ai opencode run "implement dark mode toggle"'),
+			description: 'Run a coding task',
+		},
+		{
+			command: getCommand('ai opencode run --sandbox "run the test suite"'),
+			description: 'Run in a cloud sandbox',
+		},
+		{
+			command: getCommand('ai opencode run --json "fix the bug"'),
+			description: 'Output raw JSON events',
+		},
+	],
+	async handler(
+		ctx: CommandContext<{ auth: true }, undefined, typeof RunArgsSchema, typeof RunOptionsSchema>
+	) {
+		const { logger, args, opts } = ctx;
+		const { task } = args;
+		const sandbox = opts?.sandbox;
+		const json = opts?.json;
+
+		if (!json) {
+			tui.newline();
+			tui.output(tui.bold('Agentuity Coder'));
+			tui.newline();
+			tui.output(`${tui.ICONS.arrow} Running task: ${task}`);
+			if (sandbox) {
+				tui.info('Sandbox mode enabled');
+			}
+			tui.newline();
+		}
+
+		const openCodeArgs = ['run', '--agent', 'Agentuity Coder Lead'];
+
+		if (json) {
+			openCodeArgs.push('--format', 'json');
+		}
+
+		// Build the task prompt with any mode prefixes
+		let taskPrompt = task;
+		if (sandbox) {
+			taskPrompt = `[SANDBOX MODE: Execute all code in an Agentuity cloud sandbox, not locally] ${taskPrompt}`;
+		}
+		if (json) {
+			taskPrompt = `[JSON OUTPUT: Your final response MUST be a valid JSON object with this structure: {"status": "success" | "failed" | "partial", "summary": "Brief description of what was done", "filesChanged": ["path/to/file.ts"], "errors": ["error message if any"], "payload": <any task-specific return data or null>}. Output ONLY the JSON, no other text.] ${taskPrompt}`;
+		}
+
+		openCodeArgs.push(taskPrompt);
+
+		logger.debug(`Spawning: opencode ${openCodeArgs.join(' ')}`);
+
+		const proc = Bun.spawn(['opencode', ...openCodeArgs], {
+			stdio: ['inherit', 'inherit', 'inherit'],
+			env: {
+				...process.env,
+				AGENTUITY_CODER_MODE: 'non-interactive',
+			},
+		});
+
+		const exitCode = await proc.exited;
+
+		// In JSON mode, let opencode's output speak for itself - exit code indicates success
+		if (json) {
+			process.exit(exitCode);
+		}
+
+		if (exitCode === 0) {
+			tui.newline();
+			tui.success('Task completed');
+		} else {
+			tui.newline();
+			tui.error(`Task failed with exit code ${exitCode}`);
+		}
+
+		return { success: exitCode === 0, task, exitCode, sandbox: !!sandbox };
+	},
+});
+
+export default runSubcommand;

package/src/cmd/ai/opencode/uninstall.ts

@@ -0,0 +1,90 @@
+import { readFileSync, writeFileSync, existsSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { createSubcommand } from '../../../types';
+import * as tui from '../../../tui';
+import { getCommand } from '../../../command-prefix';
+
+const OPENCODE_CONFIG_DIR = join(homedir(), '.config', 'opencode');
+const OPENCODE_CONFIG_FILE = join(OPENCODE_CONFIG_DIR, 'opencode.json');
+
+export const uninstallSubcommand = createSubcommand({
+	name: 'uninstall',
+	description: 'Uninstall Agentuity Open Code plugin',
+	tags: ['fast'],
+	examples: [
+		{
+			command: getCommand('ai opencode uninstall'),
+			description: 'Uninstall Agentuity Open Code plugin',
+		},
+	],
+	async handler(ctx) {
+		const { options } = ctx;
+		const jsonMode = !!options?.json;
+
+		if (!jsonMode) {
+			tui.newline();
+			tui.output(tui.bold('Uninstalling Agentuity Open Code plugin'));
+			tui.newline();
+		}
+
+		let removedFromOpenCode = false;
+
+		// Remove from OpenCode config
+		if (!existsSync(OPENCODE_CONFIG_FILE)) {
+			if (!jsonMode) {
+				tui.info('Open Code config not found - nothing to uninstall');
+			}
+		} else {
+			try {
+				const content = readFileSync(OPENCODE_CONFIG_FILE, 'utf-8');
+				const openCodeConfig: { plugin?: string[]; $schema?: string } = JSON.parse(content);
+
+				if (!openCodeConfig.plugin || openCodeConfig.plugin.length === 0) {
+					if (!jsonMode) {
+						tui.info('No plugins configured in Open Code');
+					}
+				} else {
+					const originalLength = openCodeConfig.plugin.length;
+					openCodeConfig.plugin = openCodeConfig.plugin.filter(
+						(p) => p !== '@agentuity/opencode'
+					);
+
+					if (openCodeConfig.plugin.length < originalLength) {
+						writeFileSync(OPENCODE_CONFIG_FILE, JSON.stringify(openCodeConfig, null, 2));
+						if (!jsonMode) {
+							tui.success('Removed Agentuity Open Code plugin');
+						}
+						removedFromOpenCode = true;
+					} else {
+						if (!jsonMode) {
+							tui.info('Agentuity Open Code plugin not found');
+						}
+					}
+				}
+			} catch (error) {
+				if (!jsonMode) {
+					tui.warn(`Failed to parse Open Code config: ${error}`);
+				}
+			}
+		}
+
+		if (!jsonMode) {
+			tui.newline();
+
+			if (removedFromOpenCode) {
+				tui.output(tui.bold('Agentuity Open Code plugin uninstalled successfully'));
+			} else {
+				tui.output(tui.bold('Agentuity Open Code plugin was not installed'));
+			}
+
+			tui.newline();
+			tui.info(`To reinstall, run: ${tui.bold(getCommand('ai opencode install'))}`);
+			tui.newline();
+		}
+
+		return { success: true, removedFromOpenCode };
+	},
+});
+
+export default uninstallSubcommand;

package/src/cmd/build/vite/beacon-plugin.ts

@@ -104,7 +104,9 @@ export function beaconPlugin(options: BeaconPluginOptions): Plugin {
 					source: beaconCode,
 				});
 			} catch (error) {
-				this.error(`Failed to read beacon script: ${error instanceof Error ? error.message : String(error)}`);
+				this.error(
+					`Failed to read beacon script: ${error instanceof Error ? error.message : String(error)}`
+				);
 			}
 		},
 

package/src/cmd/build/vite/vite-builder.ts

@@ -142,7 +142,11 @@ export async function runViteBuild(options: ViteBuildOptions): Promise<void> {
 		const htmlPath = join(rootDir, 'src', 'web', 'index.html');
 
 		// Use workbench config passed from runAllBuilds
-		const { workbenchEnabled = false, workbenchRoute = '/workbench', analyticsEnabled = false } = options;
+		const {
+			workbenchEnabled = false,
+			workbenchRoute = '/workbench',
+			analyticsEnabled = false,
+		} = options;
 
 		// Load custom user plugins from agentuity.config.ts if it exists
 		const clientOutDir = join(rootDir, '.agentuity/client');