@agentuity/cli 0.1.12 → 0.1.14

package/src/cli.ts

@@ -1,8 +1,6 @@
-import { mkdir, unlink } from 'node:fs/promises';
 import { homedir } from 'node:os';
-import { resolve, join } from 'node:path';
+import { resolve } from 'node:path';
 import { Command } from 'commander';
-import { getDefaultConfigDir } from './config';
 import type {
 	CommandDefinition,
 	SubcommandDefinition,
@@ -17,7 +15,8 @@ import type {
 } from './types';
 import { showBanner, generateBanner } from './banner';
 import { requireAuth, optionalAuth, requireOrg, optionalOrg as selectOptionalOrg } from './auth';
-import { listRegions, type RegionList, ValidationOutputError } from '@agentuity/server';
+import { type RegionList, ValidationOutputError } from '@agentuity/server';
+import { fetchRegionsWithCache } from './regions';
 import enquirer from 'enquirer';
 import * as tui from './tui';
 import { parseArgsSchema, parseOptionsSchema, buildValidationInput } from './schema-parser';
@@ -27,6 +26,7 @@ import { ErrorCode, ExitCode, createError, exitWithError } from './errors';
 import { getCommand } from './command-prefix';
 import { isValidateMode, outputValidation, type ValidationResult } from './output';
 import { StructuredError } from '@agentuity/core';
+import { setProgram } from './program-ref';
 
 /**
  * Check if an error is a CLI input validation error (Zod error from schema parsing),
@@ -462,6 +462,7 @@ async function promptProjectSelection(baseCtx: CommandContext): Promise<ProjectC
 
 export async function createCLI(version: string): Promise<Command> {
 	const program = new Command();
+	setProgram(program);
 
 	program
 		.name('agentuity')
@@ -690,89 +691,6 @@ interface ResolveRegionOptions {
 	region?: string;
 }
 
-const REGIONS_CACHE_MAX_AGE_MS = 5 * 24 * 60 * 60 * 1000; // 5 days
-const LEGACY_REGIONS_CACHE_FILE = 'regions.json';
-
-function getRegionsCacheFile(profileName: string): string {
-	return `regions-${profileName}.json`;
-}
-
-async function removeLegacyRegionsCache(logger: Logger): Promise<void> {
-	try {
-		const legacyPath = join(getDefaultConfigDir(), LEGACY_REGIONS_CACHE_FILE);
-		const file = Bun.file(legacyPath);
-		if (await file.exists()) {
-			await unlink(legacyPath);
-			logger.trace('removed legacy regions cache file');
-		}
-	} catch {
-		// Ignore errors when removing legacy file
-	}
-}
-
-interface RegionsCacheData {
-	timestamp: number;
-	regions: RegionList;
-}
-
-async function getCachedRegions(profileName: string, logger: Logger): Promise<RegionList | null> {
-	try {
-		// Clean up legacy single-file cache from older versions
-		await removeLegacyRegionsCache(logger);
-
-		const cachePath = join(getDefaultConfigDir(), getRegionsCacheFile(profileName));
-		const file = Bun.file(cachePath);
-		if (!(await file.exists())) {
-			return null;
-		}
-		const data: RegionsCacheData = await file.json();
-		const age = Date.now() - data.timestamp;
-		if (age > REGIONS_CACHE_MAX_AGE_MS) {
-			logger.trace('regions cache expired for profile %s (age: %dms)', profileName, age);
-			return null;
-		}
-		logger.trace('using cached regions for profile %s (age: %dms)', profileName, age);
-		return data.regions;
-	} catch (error) {
-		logger.trace('failed to read regions cache for profile %s: %s', profileName, error);
-		return null;
-	}
-}
-
-async function saveRegionsCache(
-	profileName: string,
-	regions: RegionList,
-	logger: Logger
-): Promise<void> {
-	try {
-		const cacheDir = getDefaultConfigDir();
-		await mkdir(cacheDir, { recursive: true });
-		const cachePath = join(cacheDir, getRegionsCacheFile(profileName));
-		const data: RegionsCacheData = {
-			timestamp: Date.now(),
-			regions,
-		};
-		await Bun.write(cachePath, JSON.stringify(data));
-		logger.trace('saved regions cache for profile %s', profileName);
-	} catch (error) {
-		logger.trace('failed to save regions cache for profile %s: %s', profileName, error);
-	}
-}
-
-async function fetchRegionsWithCache(
-	profileName: string,
-	apiClient: APIClientType,
-	logger: Logger
-): Promise<RegionList> {
-	const cached = await getCachedRegions(profileName, logger);
-	if (cached) {
-		return cached;
-	}
-	const regions = await listRegions(apiClient);
-	await saveRegionsCache(profileName, regions, logger);
-	return regions;
-}
-
 async function resolveRegion(opts: ResolveRegionOptions): Promise<string | undefined> {
 	const { options, regions, logger, required } = opts;
 
@@ -1242,7 +1160,12 @@ async function registerSubcommand(
 							ctx as CommandContext & { apiClient: APIClientType }
 						);
 					}
-					if ((normalized.requiresRegion || normalized.optionalRegion) && ctx.apiClient) {
+					if (
+						(normalized.requiresRegion ||
+							normalized.optionalRegion ||
+							normalized.requiresRegions) &&
+						ctx.apiClient
+					) {
 						const apiClient: APIClientType = ctx.apiClient as APIClientType;
 						const regions = await tui.spinner({
 							message: 'Fetching cloud regions',
@@ -1255,15 +1178,20 @@ async function registerSubcommand(
 								);
 							},
 						});
-						const region = await resolveRegion({
-							options: options as Record<string, unknown>,
-							regions,
-							logger: baseCtx.logger,
-							required: !!normalized.requiresRegion,
-							region: project?.region,
-						});
-						if (region) {
-							ctx.region = region;
+						if (normalized.requiresRegions) {
+							ctx.regions = regions;
+						}
+						if (normalized.requiresRegion || normalized.optionalRegion) {
+							const region = await resolveRegion({
+								options: options as Record<string, unknown>,
+								regions,
+								logger: baseCtx.logger,
+								required: !!normalized.requiresRegion,
+								region: project?.region,
+							});
+							if (region) {
+								ctx.region = region;
+							}
 						}
 					}
 					await executeOrValidate(
@@ -1318,7 +1246,12 @@ async function registerSubcommand(
 						ctx as CommandContext & { apiClient: APIClientType }
 					);
 				}
-				if ((normalized.requiresRegion || normalized.optionalRegion) && ctx.apiClient) {
+				if (
+					(normalized.requiresRegion ||
+						normalized.optionalRegion ||
+						normalized.requiresRegions) &&
+					ctx.apiClient
+				) {
 					const apiClient: APIClientType = ctx.apiClient as APIClientType;
 					const regions = await tui.spinner({
 						message: 'Fetching cloud regions',
@@ -1331,15 +1264,20 @@ async function registerSubcommand(
 							);
 						},
 					});
-					const region = await resolveRegion({
-						options: options as Record<string, unknown>,
-						regions,
-						logger: baseCtx.logger,
-						required: !!normalized.requiresRegion,
-						region: project?.region,
-					});
-					if (region) {
-						ctx.region = region;
+					if (normalized.requiresRegions) {
+						ctx.regions = regions;
+					}
+					if (normalized.requiresRegion || normalized.optionalRegion) {
+						const region = await resolveRegion({
+							options: options as Record<string, unknown>,
+							regions,
+							logger: baseCtx.logger,
+							required: !!normalized.requiresRegion,
+							region: project?.region,
+						});
+						if (region) {
+							ctx.region = region;
+						}
 					}
 				}
 				if (subcommand.handler) {
@@ -1384,7 +1322,13 @@ async function registerSubcommand(
 				);
 			}
 
-			const auth = await optionalAuth(baseCtx as CommandContext<undefined>, continueText);
+			// Check if --confirm flag is set to skip interactive prompts
+			const skipPrompts = options.confirm === true;
+			const auth = await optionalAuth(
+				baseCtx as CommandContext<undefined>,
+				continueText,
+				skipPrompts
+			);
 
 			if (subcommand.schema) {
 				try {

package/src/cmd/auth/index.ts

@@ -5,6 +5,7 @@ import { logoutCommand } from './logout';
 import { signupCommand } from './signup';
 import { whoamiCommand } from './whoami';
 import { sshSubcommand } from './ssh';
+import { orgSubcommand } from './org';
 import { getCommand } from '../../command-prefix';
 
 export const command = createCommand({
@@ -14,6 +15,7 @@ export const command = createCommand({
 	examples: [
 		{ command: getCommand('auth login'), description: 'Login to your account' },
 		{ command: getCommand('auth whoami'), description: 'Show current user info' },
+		{ command: getCommand('auth org select'), description: 'Set default organization' },
 	],
 	subcommands: [
 		apikeyCommand,
@@ -22,5 +24,6 @@ export const command = createCommand({
 		signupCommand,
 		whoamiCommand,
 		sshSubcommand,
+		orgSubcommand,
 	],
 });

package/src/cmd/auth/org/index.ts

@@ -0,0 +1,142 @@
+import { z } from 'zod';
+import { createSubcommand, createCommand } from '../../../types';
+import { getCommand } from '../../../command-prefix';
+import { saveOrgId, clearOrgId } from '../../../config';
+import * as tui from '../../../tui';
+import { listOrganizations } from '@agentuity/server';
+
+const selectCommand = createSubcommand({
+	name: 'select',
+	description: 'Set the default organization for all commands',
+	tags: ['fast', 'requires-auth'],
+	requires: { auth: true, apiClient: true },
+	examples: [
+		{ command: getCommand('auth org select'), description: 'Select default organization' },
+		{
+			command: getCommand('auth org select org_abc123'),
+			description: 'Set specific organization as default',
+		},
+	],
+	schema: {
+		args: z.object({
+			org_id: z.string().optional().describe('Organization ID to set as default'),
+		}),
+		response: z.object({
+			orgId: z.string().describe('The selected organization ID'),
+			name: z.string().describe('The organization name'),
+		}),
+	},
+
+	async handler(ctx) {
+		const { apiClient, args, options } = ctx;
+		const argOrgId = args.org_id;
+
+		const orgs = await tui.spinner({
+			message: 'Fetching organizations',
+			clearOnSuccess: true,
+			callback: () => listOrganizations(apiClient),
+		});
+
+		if (orgs.length === 0) {
+			tui.fatal('No organizations found for your account');
+		}
+
+		let selectedOrgId = argOrgId;
+
+		if (selectedOrgId) {
+			const org = orgs.find((o) => o.id === selectedOrgId);
+			if (!org) {
+				tui.fatal(
+					`Organization '${selectedOrgId}' not found. Use '${getCommand('auth org select')}' to see available organizations.`
+				);
+			}
+		} else {
+			if (!process.stdin.isTTY) {
+				tui.fatal(
+					'Organization ID required in non-interactive mode. Usage: ' +
+						getCommand('auth org select <org_id>')
+				);
+			}
+			selectedOrgId = await tui.selectOrganization(orgs);
+		}
+
+		await saveOrgId(selectedOrgId);
+
+		const selectedOrg = orgs.find((o) => o.id === selectedOrgId)!;
+
+		if (!options.json) {
+			tui.success(`Default organization set to ${tui.bold(selectedOrg.name)}`);
+		}
+
+		return { orgId: selectedOrgId, name: selectedOrg.name };
+	},
+});
+
+const unselectCommand = createSubcommand({
+	name: 'unselect',
+	description: 'Clear the default organization preference',
+	tags: ['fast'],
+	examples: [
+		{ command: getCommand('auth org unselect'), description: 'Clear default organization' },
+	],
+	schema: {
+		response: z.object({
+			cleared: z.boolean().describe('Whether the preference was cleared'),
+		}),
+	},
+
+	async handler(ctx) {
+		const { options, config } = ctx;
+
+		const hadOrg = !!config?.preferences?.orgId;
+		await clearOrgId();
+
+		if (!options.json) {
+			if (hadOrg) {
+				tui.success('Default organization cleared');
+			} else {
+				tui.info('No default organization was set');
+			}
+		}
+
+		return { cleared: hadOrg };
+	},
+});
+
+const currentCommand = createSubcommand({
+	name: 'current',
+	description: 'Show the current default organization',
+	tags: ['read-only', 'fast'],
+	idempotent: true,
+	examples: [
+		{ command: getCommand('auth org current'), description: 'Show default organization' },
+		{ command: getCommand('auth org current --json'), description: 'Show output in JSON format' },
+	],
+	schema: {
+		response: z.string().nullable().describe('The current organization ID or null if not set'),
+	},
+
+	async handler(ctx) {
+		const { options, config } = ctx;
+		const orgId = config?.preferences?.orgId || null;
+
+		if (!options.json) {
+			if (orgId) {
+				console.log(orgId);
+			}
+		}
+
+		return orgId;
+	},
+});
+
+export const orgSubcommand = createCommand({
+	name: 'org',
+	description: 'Manage default organization preference',
+	tags: ['fast'],
+	examples: [
+		{ command: getCommand('auth org select'), description: 'Set default organization' },
+		{ command: getCommand('auth org current'), description: 'Show current default' },
+	],
+	subcommands: [selectCommand, unselectCommand, currentCommand],
+});

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

@@ -0,0 +1,162 @@
+/**
+ * Vite plugin to emit the analytics beacon as a hashed CDN asset
+ *
+ * This plugin:
+ * 1. Reads the pre-built beacon from @agentuity/frontend
+ * 2. Emits it as a Rollup asset with content-based hashing
+ * 3. Injects a <script data-agentuity-beacon> tag into the HTML
+ */
+
+import type { Plugin, ResolvedConfig } from 'vite';
+import { join } from 'node:path';
+import { createRequire } from 'node:module';
+
+export interface BeaconPluginOptions {
+	/** Whether analytics is enabled */
+	enabled: boolean;
+}
+
+/**
+ * Read the pre-built beacon script from @agentuity/frontend package
+ * @param projectRoot - The root directory of the project (for resolving node_modules)
+ */
+async function readBeaconScript(projectRoot: string): Promise<string> {
+	let frontendPath: string | null = null;
+
+	// Strategy 1: Use Bun.resolve (works with workspaces and symlinks)
+	try {
+		frontendPath = await Bun.resolve('@agentuity/frontend', projectRoot);
+	} catch {
+		// Not found from project root
+	}
+
+	// Strategy 2: Try from this file's directory (for installed CLI case)
+	if (!frontendPath) {
+		try {
+			const thisDir = new URL('.', import.meta.url).pathname;
+			frontendPath = await Bun.resolve('@agentuity/frontend', thisDir);
+		} catch {
+			// Not found from CLI directory
+		}
+	}
+
+	// Strategy 3: Fallback to createRequire for Node.js compatibility
+	if (!frontendPath) {
+		try {
+			const projectRequire = createRequire(join(projectRoot, 'package.json'));
+			frontendPath = projectRequire.resolve('@agentuity/frontend');
+		} catch {
+			// Not found via createRequire
+		}
+	}
+
+	if (!frontendPath) {
+		throw new Error(
+			'Could not resolve @agentuity/frontend. Ensure the package is installed and built.'
+		);
+	}
+
+	// The beacon.js file is in the dist folder of @agentuity/frontend
+	// frontendPath points to dist/index.js, so we go up one level
+	const packageDir = join(frontendPath, '..');
+	const beaconPath = join(packageDir, 'beacon.js');
+
+	const beaconFile = Bun.file(beaconPath);
+	if (!(await beaconFile.exists())) {
+		throw new Error(
+			`Beacon script not found at ${beaconPath}. Run "bun run build" in @agentuity/frontend first.`
+		);
+	}
+
+	return beaconFile.text();
+}
+
+/**
+ * Vite plugin that emits the analytics beacon as a hashed asset
+ * and injects a script tag into the HTML
+ */
+export function beaconPlugin(options: BeaconPluginOptions): Plugin {
+	const { enabled } = options;
+
+	let resolvedConfig: ResolvedConfig | null = null;
+	let beaconReferenceId: string | null = null;
+
+	return {
+		name: 'agentuity:beacon',
+		apply: 'build',
+
+		configResolved(config) {
+			resolvedConfig = config;
+		},
+
+		async buildStart() {
+			if (!enabled) return;
+
+			try {
+				// Get project root from Vite config
+				const projectRoot = resolvedConfig?.root || process.cwd();
+				const beaconCode = await readBeaconScript(projectRoot);
+
+				// Emit the beacon as an asset - Rollup will hash it
+				beaconReferenceId = this.emitFile({
+					type: 'asset',
+					name: 'agentuity-beacon.js',
+					source: beaconCode,
+				});
+			} catch (error) {
+				this.error(`Failed to read beacon script: ${error instanceof Error ? error.message : String(error)}`);
+			}
+		},
+
+		// Use transformIndexHtml hook to modify the HTML
+		// This is called during the HTML transformation phase and works with Vite's HTML pipeline
+		transformIndexHtml: {
+			order: 'post',
+			handler(html, ctx) {
+				if (!enabled || !beaconReferenceId) return html;
+
+				// Get the final hashed filename using the bundle from the context
+				// We need to use ctx.bundle to access the emitted file
+				const bundle = ctx.bundle;
+				if (!bundle) return html;
+
+				// Find our beacon asset in the bundle
+				let beaconFileName: string | null = null;
+				for (const fileName of Object.keys(bundle)) {
+					if (fileName.includes('agentuity-beacon') && fileName.endsWith('.js')) {
+						beaconFileName = fileName;
+						break;
+					}
+				}
+
+				if (!beaconFileName) return html;
+
+				// Build the beacon URL using Vite's configured base (respects CDN URL)
+				// resolvedConfig.base is e.g., "https://cdn.agentuity.com/{deploymentId}/client/" or "/"
+				const base = resolvedConfig?.base || '/';
+				// Normalize: ensure base ends with / and beaconFileName doesn't start with /
+				const normalizedBase = base.endsWith('/') ? base : `${base}/`;
+				const normalizedFileName = beaconFileName.startsWith('/')
+					? beaconFileName.slice(1)
+					: beaconFileName;
+				const beaconUrl = `${normalizedBase}${normalizedFileName}`;
+
+				// Inject a marker script tag
+				// The script must be sync (no async/defer) to patch history API before router loads
+				// Use data-agentuity-beacon attribute as a marker for config/session injection
+				const beaconScript = `<script data-agentuity-beacon src="${beaconUrl}"></script>`;
+
+				// Inject before </head>
+				if (html.includes('</head>')) {
+					return html.replace('</head>', `${beaconScript}</head>`);
+				}
+				// Fallback: inject at start of body
+				if (html.includes('<body')) {
+					return html.replace(/<body([^>]*)>/, `<body$1>${beaconScript}`);
+				}
+
+				return beaconScript + html;
+			},
+		},
+	};
+}

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

@@ -10,6 +10,7 @@ import { createRequire } from 'node:module';
 import type { InlineConfig, Plugin } from 'vite';
 import type { Logger, DeployOptions } from '../../../types';
 import { browserEnvPlugin } from './browser-env-plugin';
+import { beaconPlugin } from './beacon-plugin';
 import type { BuildReportCollector } from '../../../build-report';
 
 /**
@@ -55,6 +56,8 @@ export interface ViteBuildOptions {
 	deploymentId?: string;
 	workbenchRoute?: string;
 	workbenchEnabled?: boolean;
+	/** Whether analytics is enabled (for beacon injection in client build) */
+	analyticsEnabled?: boolean;
 	logger: Logger;
 	deploymentOptions?: DeployOptions;
 	/** Optional collector for structured error reporting */
@@ -139,11 +142,17 @@ 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' } = 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');
-		const plugins = [react(), browserEnvPlugin(), flattenHtmlOutputPlugin(clientOutDir)];
+		const plugins = [
+			react(),
+			browserEnvPlugin(),
+			flattenHtmlOutputPlugin(clientOutDir),
+			// Emit analytics beacon as hashed CDN asset (prod builds only)
+			beaconPlugin({ enabled: analyticsEnabled && !dev }),
+		];
 		const { loadAgentuityConfig } = await import('./config-loader');
 		const userConfig = await loadAgentuityConfig(rootDir, logger);
 		const userPlugins = userConfig?.plugins || [];
@@ -312,6 +321,9 @@ export async function runAllBuilds(options: Omit<ViteBuildOptions, 'mode'>): Pro
 	// Check if web frontend exists
 	const hasWebFrontend = await Bun.file(join(rootDir, 'src', 'web', 'index.html')).exists();
 
+	// Check if analytics is enabled
+	const analyticsEnabled = config?.analytics !== false;
+
 	// 2. Build client (only if web frontend exists)
 	if (hasWebFrontend) {
 		logger.debug('Building client assets...');
@@ -322,6 +334,7 @@ export async function runAllBuilds(options: Omit<ViteBuildOptions, 'mode'>): Pro
 			mode: 'client',
 			workbenchEnabled: workbenchConfig.enabled,
 			workbenchRoute: workbenchConfig.route,
+			analyticsEnabled,
 		});
 		result.client.included = true;
 		result.client.duration = Date.now() - started;

package/src/cmd/build/webanalytics-generator.ts

@@ -114,6 +114,9 @@ import type { AnalyticsConfig } from './analytics-config';
 // Inject analytics config and script into HTML
 // Note: Only static config is injected (org, project, devmode, tracking options)
 // Session and thread IDs are read from cookies by the beacon script
+//
+// In production: beacon is served from CDN as a hashed asset (injected by Vite build)
+// In development: beacon is served from /_agentuity/webanalytics/analytics.js route
 export function injectAnalytics(html: string, analyticsConfig: AnalyticsConfig): string {
 	if (!analyticsConfig.enabled) return html;
 
@@ -132,7 +135,17 @@ export function injectAnalytics(html: string, analyticsConfig: AnalyticsConfig):
 	const configScript = \`<script>window.__AGENTUITY_ANALYTICS__=\${JSON.stringify(pageConfig)};</script>\`;
 	// Session script sets cookies and window.__AGENTUITY_SESSION__ (dynamic, not cached)
 	const sessionScript = '<script src="/_agentuity/webanalytics/session.js" async></script>';
-	// Beacon script - must be sync (not async/defer) to patch history API before the router loads
+
+	// In production, the beacon is already in HTML as a CDN asset (data-agentuity-beacon marker)
+	// Inject config/session BEFORE the beacon marker so config exists when beacon runs
+	const beaconMarker = '<script data-agentuity-beacon';
+	if (html.includes(beaconMarker)) {
+		// Production: inject config/session right before the beacon script
+		const injection = configScript + sessionScript;
+		return html.replace(beaconMarker, injection + beaconMarker);
+	}
+
+	// Development: beacon served from local route, inject all three scripts
 	const beaconScript = '<script src="/_agentuity/webanalytics/analytics.js"></script>';
 	const injection = configScript + sessionScript + beaconScript;
 
@@ -167,15 +180,18 @@ export function registerAnalyticsRoutes(app: ReturnType<typeof createRouter>): v
 		});
 	});
 
-	// Static beacon script - can be cached
-	app.get('/_agentuity/webanalytics/analytics.js', async (c: Context) => {
-		return new Response(BEACON_SCRIPT, {
-			headers: {
-				'Content-Type': 'application/javascript; charset=utf-8',
-				'Cache-Control': 'public, max-age=3600',
-			},
+	// Dev mode only: serve beacon script from local route
+	// In production, the beacon is served from CDN as a hashed asset
+	if (runtimeIsDevMode()) {
+		app.get('/_agentuity/webanalytics/analytics.js', async (c: Context) => {
+			return new Response(BEACON_SCRIPT, {
+				headers: {
+					'Content-Type': 'application/javascript; charset=utf-8',
+					'Cache-Control': 'no-store, no-cache, must-revalidate',
+				},
+			});
 		});
-	});
+	}
 }
 `;
 }

package/src/cmd/cloud/db/get.ts

@@ -12,6 +12,8 @@ const DBGetResponseSchema = z
 		name: z.string().describe('Database name'),
 		description: z.string().optional().describe('Database description'),
 		url: z.string().optional().describe('Database connection URL'),
+		org_id: z.string().optional().describe('Organization ID that owns this database'),
+		org_name: z.string().optional().describe('Organization name that owns this database'),
 	})
 	.or(
 		z.object({
@@ -175,6 +177,9 @@ export const getSubcommand = createSubcommand({
 			const tableData: Record<string, string> = {
 				Name: tui.bold(db.name),
 			};
+			if (db.org_name || db.org_id) {
+				tableData['Organization'] = db.org_name || db.org_id;
+			}
 			if (db.description) {
 				tableData['Description'] = db.description;
 			}
@@ -192,6 +197,8 @@ export const getSubcommand = createSubcommand({
 			name: db.name,
 			description: db.description ?? undefined,
 			url: db.url ?? undefined,
+			org_id: db.org_id,
+			org_name: db.org_name,
 		};
 	},
 });