@agentuity/cli 0.1.15 → 0.1.17

package/src/cmd/build/ast.ts

@@ -1362,8 +1362,16 @@ export async function parseRoute(
 	let exportName: string | undefined;
 	let variableName: string | undefined;
 
+	// Import info structure for tracking where identifiers come from
+	interface ImportInfo {
+		modulePath: string;
+		importedName: string; // The exported name from the source module
+		importKind: 'named' | 'default';
+	}
+
 	// Extract import statements to map variable names to their import sources
-	const importMap = new Map<string, string>(); // Maps variable name to import path
+	const importMap = new Map<string, string>(); // Maps variable name to import path (for backwards compat)
+	const importInfoMap = new Map<string, ImportInfo>(); // Maps variable name to full import info
 	for (const body of ast.body) {
 		if (body.type === 'ImportDeclaration') {
 			const importDecl = body as {
@@ -1371,6 +1379,7 @@ export async function parseRoute(
 				specifiers?: Array<{
 					type: string;
 					local?: { name?: string };
+					imported?: { name?: string }; // For named imports: the exported name
 				}>;
 			};
 			const importPath = importDecl.source?.value;
@@ -1379,9 +1388,20 @@ export async function parseRoute(
 					if (spec.type === 'ImportDefaultSpecifier' && spec.local?.name) {
 						// import hello from '@agent/hello'
 						importMap.set(spec.local.name, importPath);
+						importInfoMap.set(spec.local.name, {
+							modulePath: importPath,
+							importedName: 'default',
+							importKind: 'default',
+						});
 					} else if (spec.type === 'ImportSpecifier' && spec.local?.name) {
-						// import { hello } from './shared'
+						// import { hello } from './shared' or import { hello as h } from './shared'
+						const importedName = spec.imported?.name ?? spec.local.name;
 						importMap.set(spec.local.name, importPath);
+						importInfoMap.set(spec.local.name, {
+							modulePath: importPath,
+							importedName,
+							importKind: 'named',
+						});
 					}
 				}
 			}
@@ -1620,10 +1640,29 @@ export async function parseRoute(
 										if (validatorInfo.inputSchemaVariable) {
 											routeConfig.inputSchemaVariable =
 												validatorInfo.inputSchemaVariable;
+											// Track where the schema is imported from (if imported)
+											const inputImportInfo = importInfoMap.get(
+												validatorInfo.inputSchemaVariable
+											);
+											if (inputImportInfo) {
+												routeConfig.inputSchemaImportPath = inputImportInfo.modulePath;
+												routeConfig.inputSchemaImportedName =
+													inputImportInfo.importedName;
+											}
 										}
 										if (validatorInfo.outputSchemaVariable) {
 											routeConfig.outputSchemaVariable =
 												validatorInfo.outputSchemaVariable;
+											// Track where the schema is imported from (if imported)
+											const outputImportInfo = importInfoMap.get(
+												validatorInfo.outputSchemaVariable
+											);
+											if (outputImportInfo) {
+												routeConfig.outputSchemaImportPath =
+													outputImportInfo.modulePath;
+												routeConfig.outputSchemaImportedName =
+													outputImportInfo.importedName;
+											}
 										}
 										if (validatorInfo.stream !== undefined) {
 											routeConfig.stream = validatorInfo.stream;
@@ -1700,10 +1739,29 @@ export async function parseRoute(
 										if (validatorInfo.inputSchemaVariable) {
 											routeConfig.inputSchemaVariable =
 												validatorInfo.inputSchemaVariable;
+											// Track where the schema is imported from (if imported)
+											const inputImportInfo = importInfoMap.get(
+												validatorInfo.inputSchemaVariable
+											);
+											if (inputImportInfo) {
+												routeConfig.inputSchemaImportPath = inputImportInfo.modulePath;
+												routeConfig.inputSchemaImportedName =
+													inputImportInfo.importedName;
+											}
 										}
 										if (validatorInfo.outputSchemaVariable) {
 											routeConfig.outputSchemaVariable =
 												validatorInfo.outputSchemaVariable;
+											// Track where the schema is imported from (if imported)
+											const outputImportInfo = importInfoMap.get(
+												validatorInfo.outputSchemaVariable
+											);
+											if (outputImportInfo) {
+												routeConfig.outputSchemaImportPath =
+													outputImportInfo.modulePath;
+												routeConfig.outputSchemaImportedName =
+													outputImportInfo.importedName;
+											}
 										}
 										if (validatorInfo.stream !== undefined) {
 											routeConfig.stream = validatorInfo.stream;
@@ -1879,9 +1937,25 @@ export async function parseRoute(
 							);
 							if (validatorInfo.inputSchemaVariable) {
 								routeConfig.inputSchemaVariable = validatorInfo.inputSchemaVariable;
+								// Track where the schema is imported from (if imported)
+								const inputImportInfo = importInfoMap.get(
+									validatorInfo.inputSchemaVariable
+								);
+								if (inputImportInfo) {
+									routeConfig.inputSchemaImportPath = inputImportInfo.modulePath;
+									routeConfig.inputSchemaImportedName = inputImportInfo.importedName;
+								}
 							}
 							if (validatorInfo.outputSchemaVariable) {
 								routeConfig.outputSchemaVariable = validatorInfo.outputSchemaVariable;
+								// Track where the schema is imported from (if imported)
+								const outputImportInfo = importInfoMap.get(
+									validatorInfo.outputSchemaVariable
+								);
+								if (outputImportInfo) {
+									routeConfig.outputSchemaImportPath = outputImportInfo.modulePath;
+									routeConfig.outputSchemaImportedName = outputImportInfo.importedName;
+								}
 							}
 							if (validatorInfo.stream !== undefined) {
 								routeConfig.stream = validatorInfo.stream;
@@ -1894,9 +1968,21 @@ export async function parseRoute(
 						// which is useful when using zValidator (input-only) but needing typed outputs
 						if (!routeConfig.inputSchemaVariable && exportedInputSchemaName) {
 							routeConfig.inputSchemaVariable = exportedInputSchemaName;
+							// Check if exported schema name is also imported
+							const inputImportInfo = importInfoMap.get(exportedInputSchemaName);
+							if (inputImportInfo) {
+								routeConfig.inputSchemaImportPath = inputImportInfo.modulePath;
+								routeConfig.inputSchemaImportedName = inputImportInfo.importedName;
+							}
 						}
 						if (!routeConfig.outputSchemaVariable && exportedOutputSchemaName) {
 							routeConfig.outputSchemaVariable = exportedOutputSchemaName;
+							// Check if exported schema name is also imported
+							const outputImportInfo = importInfoMap.get(exportedOutputSchemaName);
+							if (outputImportInfo) {
+								routeConfig.outputSchemaImportPath = outputImportInfo.modulePath;
+								routeConfig.outputSchemaImportedName = outputImportInfo.importedName;
+							}
 						}
 
 						routes.push({

package/src/cmd/build/vite/registry-generator.ts

@@ -4,7 +4,7 @@
  * Generates src/generated/registry.ts from discovered agents
  */
 
-import { join } from 'node:path';
+import { join, dirname, relative, resolve } from 'node:path';
 import { writeFileSync, mkdirSync, existsSync, unlinkSync, readFileSync } from 'node:fs';
 import { stat } from 'node:fs/promises';
 import { StructuredError } from '@agentuity/core';
@@ -12,6 +12,45 @@ import { toCamelCase, toPascalCase } from '../../../utils/string';
 import type { AgentMetadata } from './agent-discovery';
 import type { RouteInfo } from './route-discovery';
 
+/**
+ * Rebase a relative import path from the route file's location to the generated file's location.
+ * @param routeFilename - The route file path (e.g., 'api/example/route.ts' or './api/example/route.ts')
+ * @param schemaImportPath - The import path as written in the route file (e.g., '../../utils/schemas')
+ * @param srcDir - The src directory path
+ * @returns The rebased import path relative to src/generated/
+ */
+function rebaseImportPath(routeFilename: string, schemaImportPath: string, srcDir: string): string {
+	// Non-relative imports (bare modules like '@company/schemas') should be used as-is
+	if (!schemaImportPath.startsWith('.') && !schemaImportPath.startsWith('/')) {
+		return schemaImportPath;
+	}
+
+	// Normalize route filename to get its directory relative to srcDir
+	let routeDir: string;
+	const cleanFilename = routeFilename.replace(/\\/g, '/');
+	if (cleanFilename.startsWith('./')) {
+		routeDir = dirname(join(srcDir, cleanFilename.substring(2)));
+	} else if (cleanFilename.startsWith('src/')) {
+		routeDir = dirname(join(srcDir, '..', cleanFilename));
+	} else {
+		routeDir = dirname(join(srcDir, cleanFilename));
+	}
+
+	// Resolve the schema module path from the route file's directory
+	const resolvedSchemaPath = resolve(routeDir, schemaImportPath);
+
+	// Calculate the relative path from src/generated/ to the resolved schema path
+	const generatedDir = join(srcDir, 'generated');
+	let rebasedPath = relative(generatedDir, resolvedSchemaPath).replace(/\\/g, '/');
+
+	// Ensure it starts with './' or '../'
+	if (!rebasedPath.startsWith('.') && !rebasedPath.startsWith('/')) {
+		rebasedPath = './' + rebasedPath;
+	}
+
+	return rebasedPath;
+}
+
 const AgentIdentifierCollisionError = StructuredError('AgentIdentifierCollisionError');
 
 /**
@@ -617,6 +656,8 @@ export async function generateRouteRegistry(
 	const imports: string[] = [];
 	const agentImports = new Map<string, string>();
 	const routeFileImports = new Map<string, Set<string>>();
+	// Track per-route which import path and schema name to use for alias lookup
+	const routeSchemaImportInfo = new Map<string, { importPath: string; schemaName: string }>();
 
 	// Collect agent and schema imports from routes with validators or exported schemas
 	allRoutes.forEach((route) => {
@@ -690,25 +731,76 @@ export async function generateRouteRegistry(
 		}
 
 		// Collect schema variable imports
-		if (route.inputSchemaVariable || route.outputSchemaVariable) {
-			const filename = route.filename.replace(/\\/g, '/');
-			// Remove 'src/' prefix if present (routes.filename might be './api/...' or 'src/api/...')
-			const withoutSrc = filename.startsWith('src/') ? filename.substring(4) : filename;
-			const withoutLeadingDot = withoutSrc.startsWith('./')
-				? withoutSrc.substring(2)
-				: withoutSrc;
-			const importPath = `../${withoutLeadingDot.replace(/\.ts$/, '')}`;
+		// If the schema is imported from another file, use that file's path (rebased)
+		// Otherwise fall back to the route file path (for locally defined schemas)
+		if (route.inputSchemaVariable) {
+			let importPath: string;
+			let schemaNameToImport: string;
+
+			if (route.inputSchemaImportPath) {
+				// Schema is imported - rebase the import path from route file to generated file
+				importPath = rebaseImportPath(route.filename, route.inputSchemaImportPath, srcDir);
+				// Use the actual exported name (handles aliased imports like `import { A as B }`)
+				schemaNameToImport =
+					route.inputSchemaImportedName === 'default'
+						? route.inputSchemaVariable
+						: (route.inputSchemaImportedName ?? route.inputSchemaVariable);
+			} else {
+				// Schema is locally defined - import from the route file
+				const filename = route.filename.replace(/\\/g, '/');
+				const withoutSrc = filename.startsWith('src/') ? filename.substring(4) : filename;
+				const withoutLeadingDot = withoutSrc.startsWith('./')
+					? withoutSrc.substring(2)
+					: withoutSrc;
+				importPath = `../${withoutLeadingDot.replace(/\.ts$/, '')}`;
+				schemaNameToImport = route.inputSchemaVariable;
+			}
 
 			if (!routeFileImports.has(importPath)) {
 				routeFileImports.set(importPath, new Set());
 			}
+			routeFileImports.get(importPath)!.add(schemaNameToImport);
 
-			if (route.inputSchemaVariable) {
-				routeFileImports.get(importPath)!.add(route.inputSchemaVariable);
+			// Store the resolved import info for later alias lookup
+			routeSchemaImportInfo.set(`input:${route.path}:${route.method}`, {
+				importPath,
+				schemaName: schemaNameToImport,
+			});
+		}
+
+		if (route.outputSchemaVariable) {
+			let importPath: string;
+			let schemaNameToImport: string;
+
+			if (route.outputSchemaImportPath) {
+				// Schema is imported - rebase the import path from route file to generated file
+				importPath = rebaseImportPath(route.filename, route.outputSchemaImportPath, srcDir);
+				// Use the actual exported name (handles aliased imports like `import { A as B }`)
+				schemaNameToImport =
+					route.outputSchemaImportedName === 'default'
+						? route.outputSchemaVariable
+						: (route.outputSchemaImportedName ?? route.outputSchemaVariable);
+			} else {
+				// Schema is locally defined - import from the route file
+				const filename = route.filename.replace(/\\/g, '/');
+				const withoutSrc = filename.startsWith('src/') ? filename.substring(4) : filename;
+				const withoutLeadingDot = withoutSrc.startsWith('./')
+					? withoutSrc.substring(2)
+					: withoutSrc;
+				importPath = `../${withoutLeadingDot.replace(/\.ts$/, '')}`;
+				schemaNameToImport = route.outputSchemaVariable;
 			}
-			if (route.outputSchemaVariable) {
-				routeFileImports.get(importPath)!.add(route.outputSchemaVariable);
+
+			if (!routeFileImports.has(importPath)) {
+				routeFileImports.set(importPath, new Set());
 			}
+			routeFileImports.get(importPath)!.add(schemaNameToImport);
+
+			// Store the resolved import info for later alias lookup
+			routeSchemaImportInfo.set(`output:${route.path}:${route.method}`, {
+				importPath,
+				schemaName: schemaNameToImport,
+			});
 		}
 	});
 
@@ -774,18 +866,22 @@ export async function generateRouteRegistry(
 				inputSchemaType = `typeof ${importName} extends { inputSchema?: infer I } ? I : never`;
 				outputSchemaType = `typeof ${importName} extends { outputSchema?: infer O } ? O : never`;
 			} else if (route.inputSchemaVariable || route.outputSchemaVariable) {
-				// Get the aliased schema names for this route's file
-				const filename = route.filename.replace(/\\/g, '/');
-				const withoutSrc = filename.startsWith('src/') ? filename.substring(4) : filename;
-				const withoutLeadingDot = withoutSrc.startsWith('./')
-					? withoutSrc.substring(2)
-					: withoutSrc;
-				const importPath = `../${withoutLeadingDot.replace(/\.ts$/, '')}`;
-				const aliases = schemaImportAliases.get(importPath);
+				// Get the aliased schema names using the stored import info
+				// (which correctly handles schemas imported from shared files)
+				const inputInfo = routeSchemaImportInfo.get(`input:${route.path}:${route.method}`);
+				const outputInfo = routeSchemaImportInfo.get(`output:${route.path}:${route.method}`);
+
+				let inputAlias: string | undefined;
+				let outputAlias: string | undefined;
 
-				const inputAlias = route.inputSchemaVariable && aliases?.get(route.inputSchemaVariable);
-				const outputAlias =
-					route.outputSchemaVariable && aliases?.get(route.outputSchemaVariable);
+				if (inputInfo) {
+					const aliases = schemaImportAliases.get(inputInfo.importPath);
+					inputAlias = aliases?.get(inputInfo.schemaName);
+				}
+				if (outputInfo) {
+					const aliases = schemaImportAliases.get(outputInfo.importPath);
+					outputAlias = aliases?.get(outputInfo.schemaName);
+				}
 
 				inputType = inputAlias ? `InferInput<typeof ${inputAlias}>` : 'never';
 				outputType = outputAlias ? `InferOutput<typeof ${outputAlias}>` : 'never';

package/src/cmd/build/vite/route-discovery.ts

@@ -37,6 +37,10 @@ export interface RouteInfo {
 	agentDescription?: string;
 	inputSchemaVariable?: string;
 	outputSchemaVariable?: string;
+	inputSchemaImportPath?: string;
+	inputSchemaImportedName?: string;
+	outputSchemaImportPath?: string;
+	outputSchemaImportedName?: string;
 	inputSchemaCode?: string;
 	outputSchemaCode?: string;
 	stream?: boolean;
@@ -119,6 +123,18 @@ export async function discoverRoutes(
 							agentImportPath: route.config?.agentImportPath as string | undefined,
 							inputSchemaVariable: route.config?.inputSchemaVariable as string | undefined,
 							outputSchemaVariable: route.config?.outputSchemaVariable as string | undefined,
+							inputSchemaImportPath: route.config?.inputSchemaImportPath as
+								| string
+								| undefined,
+							inputSchemaImportedName: route.config?.inputSchemaImportedName as
+								| string
+								| undefined,
+							outputSchemaImportPath: route.config?.outputSchemaImportPath as
+								| string
+								| undefined,
+							outputSchemaImportedName: route.config?.outputSchemaImportedName as
+								| string
+								| undefined,
 							stream:
 								route.config?.stream !== undefined && route.config.stream !== null
 									? Boolean(route.config.stream)

package/src/cmd/cloud/env/delete.ts

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 import { createSubcommand } from '../../../types';
 import * as tui from '../../../tui';
-import { projectEnvDelete, projectGet } from '@agentuity/server';
+import { projectEnvDelete, projectGet, orgEnvDelete, orgEnvGet } from '@agentuity/server';
 import {
 	findExistingEnvFile,
 	readEnvFile,
@@ -11,34 +11,60 @@ import {
 } from '../../../env-util';
 import { getCommand } from '../../../command-prefix';
 import { ErrorCode } from '../../../errors';
+import { resolveOrgId, isOrgScope } from './org-util';
 
 const EnvDeleteResponseSchema = z.object({
 	success: z.boolean().describe('Whether the operation succeeded'),
 	key: z.string().describe('Variable key that was deleted'),
-	path: z.string().describe('Local file path where variable was removed'),
+	path: z
+		.string()
+		.optional()
+		.describe('Local file path where variable was removed (project scope only)'),
 	secret: z.boolean().describe('Whether a secret was deleted'),
+	scope: z.enum(['project', 'org']).describe('The scope from which the variable was deleted'),
 });
 
 export const deleteSubcommand = createSubcommand({
 	name: 'delete',
 	aliases: ['del', 'remove', 'rm'],
 	description: 'Delete an environment variable or secret',
-	tags: ['destructive', 'deletes-resource', 'slow', 'requires-auth', 'requires-project'],
+	tags: ['destructive', 'deletes-resource', 'slow', 'requires-auth'],
 	idempotent: true,
 	examples: [
 		{ command: getCommand('env delete OLD_FEATURE_FLAG'), description: 'Delete variable' },
 		{ command: getCommand('env rm API_KEY'), description: 'Delete a secret' },
+		{
+			command: getCommand('env rm OPENAI_API_KEY --org'),
+			description: 'Delete org-level secret',
+		},
 	],
-	requires: { auth: true, project: true, apiClient: true },
+	requires: { auth: true, apiClient: true },
+	optional: { project: true },
 	schema: {
 		args: z.object({
 			key: z.string().describe('the variable or secret key to delete'),
 		}),
+		options: z.object({
+			org: z
+				.union([z.boolean(), z.string()])
+				.optional()
+				.describe(
+					'delete from organization level (use --org for default org, or --org <orgId> for specific org)'
+				),
+		}),
 		response: EnvDeleteResponseSchema,
 	},
 
 	async handler(ctx) {
-		const { args, project, projectDir, apiClient } = ctx;
+		const { args, project, projectDir, apiClient, config, opts } = ctx;
+		const useOrgScope = isOrgScope(opts?.org);
+
+		// Require project context if not using org scope
+		if (!useOrgScope && !project) {
+			tui.fatal(
+				'Project context required. Run from a project directory or use --org for organization scope.'
+			);
+		}
 
 		// Validate key doesn't start with reserved AGENTUITY_ prefix (except AGENTUITY_PUBLIC_)
 		if (isReservedAgentuityKey(args.key)) {
@@ -47,45 +73,91 @@ export const deleteSubcommand = createSubcommand({
 			);
 		}
 
-		// First, determine if this key exists in env or secrets
-		const projectData = await tui.spinner('Checking variable', () => {
-			return projectGet(apiClient, { id: project.projectId, mask: true });
-		});
+		if (useOrgScope) {
+			// Organization scope
+			const orgId = await resolveOrgId(apiClient, config, opts!.org!);
 
-		const isSecret = projectData.secrets?.[args.key] !== undefined;
-		const isEnv = projectData.env?.[args.key] !== undefined;
+			// First, determine if this key exists in env or secrets
+			const orgData = await tui.spinner('Checking organization variable', () => {
+				return orgEnvGet(apiClient, { id: orgId, mask: true });
+			});
 
-		if (!isSecret && !isEnv) {
-			tui.fatal(`Variable '${args.key}' not found`, ErrorCode.RESOURCE_NOT_FOUND);
-		}
+			const isSecret = orgData.secrets?.[args.key] !== undefined;
+			const isEnv = orgData.env?.[args.key] !== undefined;
+
+			if (!isSecret && !isEnv) {
+				tui.fatal(
+					`Variable '${args.key}' not found in organization`,
+					ErrorCode.RESOURCE_NOT_FOUND
+				);
+			}
 
-		// Delete from cloud using the correct field
-		const label = isSecret ? 'secret' : 'environment variable';
-		await tui.spinner(`Deleting ${label} from cloud`, () => {
-			return projectEnvDelete(apiClient, {
-				id: project.projectId,
-				...(isSecret ? { secrets: [args.key] } : { env: [args.key] }),
+			// Delete from cloud
+			const label = isSecret ? 'secret' : 'environment variable';
+			await tui.spinner(`Deleting organization ${label} from cloud`, () => {
+				return orgEnvDelete(apiClient, {
+					id: orgId,
+					...(isSecret ? { secrets: [args.key] } : { env: [args.key] }),
+				});
 			});
-		});
-
-		// Update local .env file
-		const envFilePath = await findExistingEnvFile(projectDir);
-		const currentEnv = await readEnvFile(envFilePath);
-		delete currentEnv[args.key];
-
-		// Filter out AGENTUITY_ keys before writing
-		const filteredEnv = filterAgentuitySdkKeys(currentEnv);
-		await writeEnvFile(envFilePath, filteredEnv);
-
-		tui.success(
-			`${isSecret ? 'Secret' : 'Environment variable'} '${args.key}' deleted successfully (cloud + ${envFilePath})`
-		);
-
-		return {
-			success: true,
-			key: args.key,
-			path: envFilePath,
-			secret: isSecret,
-		};
+
+			tui.success(
+				`Organization ${isSecret ? 'secret' : 'environment variable'} '${args.key}' deleted successfully`
+			);
+
+			return {
+				success: true,
+				key: args.key,
+				secret: isSecret,
+				scope: 'org' as const,
+			};
+		} else {
+			// Project scope (existing behavior)
+			const projectData = await tui.spinner('Checking variable', () => {
+				return projectGet(apiClient, { id: project!.projectId, mask: true });
+			});
+
+			const isSecret = projectData.secrets?.[args.key] !== undefined;
+			const isEnv = projectData.env?.[args.key] !== undefined;
+
+			if (!isSecret && !isEnv) {
+				tui.fatal(`Variable '${args.key}' not found`, ErrorCode.RESOURCE_NOT_FOUND);
+			}
+
+			// Delete from cloud using the correct field
+			const label = isSecret ? 'secret' : 'environment variable';
+			await tui.spinner(`Deleting ${label} from cloud`, () => {
+				return projectEnvDelete(apiClient, {
+					id: project!.projectId,
+					...(isSecret ? { secrets: [args.key] } : { env: [args.key] }),
+				});
+			});
+
+			// Update local .env file only if we have a project directory
+			// (not when using --project-id without being in a project folder)
+			let envFilePath: string | undefined;
+			if (projectDir) {
+				envFilePath = await findExistingEnvFile(projectDir);
+				const currentEnv = await readEnvFile(envFilePath);
+				delete currentEnv[args.key];
+
+				// Filter out AGENTUITY_ keys before writing
+				const filteredEnv = filterAgentuitySdkKeys(currentEnv);
+				await writeEnvFile(envFilePath, filteredEnv);
+			}
+
+			const successMsg = envFilePath
+				? `${isSecret ? 'Secret' : 'Environment variable'} '${args.key}' deleted successfully (cloud + ${envFilePath})`
+				: `${isSecret ? 'Secret' : 'Environment variable'} '${args.key}' deleted successfully (cloud only)`;
+			tui.success(successMsg);
+
+			return {
+				success: true,
+				key: args.key,
+				path: envFilePath,
+				secret: isSecret,
+				scope: 'project' as const,
+			};
+		}
 	},
 });