@agentuity/cli 0.1.16 → 0.1.18

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

@@ -16,7 +16,10 @@ 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().optional().describe('Local file path where variable was removed (project scope only)'),
+	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'),
 });
@@ -30,7 +33,10 @@ export const deleteSubcommand = createSubcommand({
 	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' },
+		{
+			command: getCommand('env rm OPENAI_API_KEY --org'),
+			description: 'Delete org-level secret',
+		},
 	],
 	requires: { auth: true, apiClient: true },
 	optional: { project: true },
@@ -42,7 +48,9 @@ export const deleteSubcommand = createSubcommand({
 			org: z
 				.union([z.boolean(), z.string()])
 				.optional()
-				.describe('delete from organization level (use --org for default org, or --org <orgId> for specific org)'),
+				.describe(
+					'delete from organization level (use --org for default org, or --org <orgId> for specific org)'
+				),
 		}),
 		response: EnvDeleteResponseSchema,
 	},
@@ -53,7 +61,9 @@ export const deleteSubcommand = createSubcommand({
 
 		// 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.');
+			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_)
@@ -76,7 +86,10 @@ export const deleteSubcommand = createSubcommand({
 			const isEnv = orgData.env?.[args.key] !== undefined;
 
 			if (!isSecret && !isEnv) {
-				tui.fatal(`Variable '${args.key}' not found in organization`, ErrorCode.RESOURCE_NOT_FOUND);
+				tui.fatal(
+					`Variable '${args.key}' not found in organization`,
+					ErrorCode.RESOURCE_NOT_FOUND
+				);
 			}
 
 			// Delete from cloud

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

@@ -21,7 +21,10 @@ export const getSubcommand = createSubcommand({
 		{ command: getCommand('env get NODE_ENV'), description: 'Get environment variable' },
 		{ command: getCommand('env get API_KEY'), description: 'Get a secret value' },
 		{ command: getCommand('env get API_KEY --no-mask'), description: 'Show unmasked value' },
-		{ command: getCommand('env get OPENAI_API_KEY --org'), description: 'Get org-level variable' },
+		{
+			command: getCommand('env get OPENAI_API_KEY --org'),
+			description: 'Get org-level variable',
+		},
 	],
 	requires: { auth: true, apiClient: true },
 	optional: { project: true },
@@ -34,7 +37,9 @@ export const getSubcommand = createSubcommand({
 			org: z
 				.union([z.boolean(), z.string()])
 				.optional()
-				.describe('get from organization level (use --org for default org, or --org <orgId> for specific org)'),
+				.describe(
+					'get from organization level (use --org for default org, or --org <orgId> for specific org)'
+				),
 		}),
 		response: EnvGetResponseSchema,
 	},
@@ -46,7 +51,9 @@ export const getSubcommand = createSubcommand({
 
 		// 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.');
+			tui.fatal(
+				'Project context required. Run from a project directory or use --org for organization scope.'
+			);
 		}
 
 		let value: string | undefined;

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

@@ -21,7 +21,10 @@ const EnvImportResponseSchema = z.object({
 	envCount: z.number().describe('Number of env vars imported'),
 	secretCount: z.number().describe('Number of secrets imported'),
 	skipped: z.number().describe('Number of items skipped'),
-	path: z.string().optional().describe('Local file path where variables were saved (project scope only)'),
+	path: z
+		.string()
+		.optional()
+		.describe('Local file path where variables were saved (project scope only)'),
 	file: z.string().describe('Source file path'),
 	scope: z.enum(['project', 'org']).describe('The scope where variables were imported'),
 });
@@ -29,13 +32,7 @@ const EnvImportResponseSchema = z.object({
 export const importSubcommand = createSubcommand({
 	name: 'import',
 	description: 'Import environment variables and secrets from a file to cloud and local .env',
-	tags: [
-		'mutating',
-		'creates-resource',
-		'slow',
-		'api-intensive',
-		'requires-auth',
-	],
+	tags: ['mutating', 'creates-resource', 'slow', 'api-intensive', 'requires-auth'],
 	examples: [
 		{
 			command: getCommand('cloud env import .env.backup'),
@@ -72,7 +69,9 @@ export const importSubcommand = createSubcommand({
 
 		// 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.');
+			tui.fatal(
+				'Project context required. Run from a project directory or use --org for organization scope.'
+			);
 		}
 
 		// Read the import file
@@ -87,7 +86,7 @@ export const importSubcommand = createSubcommand({
 				secretCount: 0,
 				skipped: 0,
 				file: args.file,
-				scope: useOrgScope ? 'org' as const : 'project' as const,
+				scope: useOrgScope ? ('org' as const) : ('project' as const),
 			};
 		}
 
@@ -103,7 +102,7 @@ export const importSubcommand = createSubcommand({
 				secretCount: 0,
 				skipped: Object.keys(importedVars).length,
 				file: args.file,
-				scope: useOrgScope ? 'org' as const : 'project' as const,
+				scope: useOrgScope ? ('org' as const) : ('project' as const),
 			};
 		}
 

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

@@ -23,7 +23,10 @@ export const listSubcommand = createSubcommand({
 		{ command: getCommand('env list --no-mask'), description: 'Show unmasked values' },
 		{ command: getCommand('env list --secrets'), description: 'List only secrets' },
 		{ command: getCommand('env list --env-only'), description: 'List only env vars' },
-		{ command: getCommand('env list --org'), description: 'List only organization-level variables' },
+		{
+			command: getCommand('env list --org'),
+			description: 'List only organization-level variables',
+		},
 	],
 	requires: { auth: true, apiClient: true },
 	optional: { project: true },
@@ -48,7 +51,9 @@ export const listSubcommand = createSubcommand({
 		if (ctx.opts?.org) {
 			return `/settings/organization/env`;
 		}
-		return ctx.project ? `/projects/${encodeURIComponent(ctx.project.projectId)}/settings` : undefined;
+		return ctx.project
+			? `/projects/${encodeURIComponent(ctx.project.projectId)}/settings`
+			: undefined;
 	},
 
 	async handler(ctx) {
@@ -56,7 +61,8 @@ export const listSubcommand = createSubcommand({
 		const useOrgScope = isOrgScope(opts?.org);
 
 		// Build combined result with type info and scope
-		const result: Record<string, { value: string; secret: boolean; scope: 'project' | 'org' }> = {};
+		const result: Record<string, { value: string; secret: boolean; scope: 'project' | 'org' }> =
+			{};
 
 		// Filter based on options
 		const showEnv = !opts?.secrets;
@@ -132,7 +138,9 @@ export const listSubcommand = createSubcommand({
 				}
 			}
 		} else {
-			tui.fatal('Project context required. Run from a project directory or use --org for organization scope.');
+			tui.fatal(
+				'Project context required. Run from a project directory or use --org for organization scope.'
+			);
 		}
 
 		// Skip TUI output in JSON mode
@@ -142,10 +150,10 @@ export const listSubcommand = createSubcommand({
 			} else {
 				tui.newline();
 
-				const projectCount = Object.values(result).filter(v => v.scope === 'project').length;
-				const orgCount = Object.values(result).filter(v => v.scope === 'org').length;
-				const secretCount = Object.values(result).filter(v => v.secret).length;
-				const envCount = Object.values(result).filter(v => !v.secret).length;
+				const projectCount = Object.values(result).filter((v) => v.scope === 'project').length;
+				const orgCount = Object.values(result).filter((v) => v.scope === 'org').length;
+				const secretCount = Object.values(result).filter((v) => v.secret).length;
+				const envCount = Object.values(result).filter((v) => !v.secret).length;
 
 				const parts: string[] = [];
 				if (envCount > 0) parts.push(`${envCount} env`);
@@ -165,7 +173,9 @@ export const listSubcommand = createSubcommand({
 					const displayValue = shouldMask && secret ? tui.maskSecret(value) : value;
 					const typeIndicator = secret ? ' [secret]' : '';
 					const scopeIndicator = !useOrgScope ? ` [${scope}]` : '';
-					console.log(`${tui.bold(key)}=${displayValue}${tui.muted(typeIndicator + scopeIndicator)}`);
+					console.log(
+						`${tui.bold(key)}=${displayValue}${tui.muted(typeIndicator + scopeIndicator)}`
+					);
 				}
 			}
 		}

package/src/cmd/cloud/env/org-util.ts

@@ -5,7 +5,7 @@ import { listOrganizations } from '@agentuity/server';
 
 /**
  * Resolves the organization ID for org-scoped env operations.
- * 
+ *
  * @param apiClient - The API client
  * @param config - The CLI config (may be null)
  * @param orgOption - The --org option value (true for default/prompt, or explicit org ID)

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

@@ -61,16 +61,21 @@ export const pullSubcommand = createSubcommand({
 			// Organization scope
 			const orgId = await resolveOrgId(apiClient, config, opts!.org!);
 
-			const orgData = await tui.spinner('Pulling environment variables from organization', () => {
-				return orgEnvGet(apiClient, { id: orgId, mask: false });
-			});
+			const orgData = await tui.spinner(
+				'Pulling environment variables from organization',
+				() => {
+					return orgEnvGet(apiClient, { id: orgId, mask: false });
+				}
+			);
 
 			cloudEnv = { ...orgData.env, ...orgData.secrets };
 			scope = 'org';
 		} else {
 			// Project scope
 			if (!project) {
-				tui.fatal('Project context required. Run from a project directory or use --org for organization scope.');
+				tui.fatal(
+					'Project context required. Run from a project directory or use --org for organization scope.'
+				);
 			}
 
 			const projectData = await tui.spinner('Pulling environment variables from cloud', () => {

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

@@ -24,13 +24,7 @@ const EnvPushResponseSchema = z.object({
 export const pushSubcommand = createSubcommand({
 	name: 'push',
 	description: 'Push environment variables and secrets from local .env file to cloud',
-	tags: [
-		'mutating',
-		'updates-resource',
-		'slow',
-		'api-intensive',
-		'requires-auth',
-	],
+	tags: ['mutating', 'updates-resource', 'slow', 'api-intensive', 'requires-auth'],
 	idempotent: true,
 	examples: [
 		{ command: getCommand('env push'), description: 'Push all variables to cloud (project)' },
@@ -73,7 +67,7 @@ export const pushSubcommand = createSubcommand({
 				envCount: 0,
 				secretCount: 0,
 				source: envFilePath,
-				scope: useOrgScope ? 'org' as const : 'project' as const,
+				scope: useOrgScope ? ('org' as const) : ('project' as const),
 			};
 		}
 
@@ -123,7 +117,9 @@ export const pushSubcommand = createSubcommand({
 		} else {
 			// Project scope (existing behavior)
 			if (!project) {
-				tui.fatal('Project context required. Run from a project directory or use --org for organization scope.');
+				tui.fatal(
+					'Project context required. Run from a project directory or use --org for organization scope.'
+				);
 			}
 
 			await tui.spinner('Pushing variables to cloud', () => {

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

@@ -18,7 +18,10 @@ import { resolveOrgId, isOrgScope } from './org-util';
 const EnvSetResponseSchema = z.object({
 	success: z.boolean().describe('Whether the operation succeeded'),
 	key: z.string().describe('Environment variable key'),
-	path: z.string().optional().describe('Local file path where env var was saved (project scope only)'),
+	path: z
+		.string()
+		.optional()
+		.describe('Local file path where env var was saved (project scope only)'),
 	secret: z.boolean().describe('Whether the value was stored as a secret'),
 	scope: z.enum(['project', 'org']).describe('The scope where the variable was set'),
 });
@@ -58,7 +61,9 @@ export const setSubcommand = createSubcommand({
 			org: z
 				.union([z.boolean(), z.string()])
 				.optional()
-				.describe('set at organization level (use --org for default org, or --org <orgId> for specific org)'),
+				.describe(
+					'set at organization level (use --org for default org, or --org <orgId> for specific org)'
+				),
 		}),
 		response: EnvSetResponseSchema,
 	},
@@ -69,7 +74,9 @@ export const setSubcommand = createSubcommand({
 
 		// 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.');
+			tui.fatal(
+				'Project context required. Run from a project directory or use --org for organization scope.'
+			);
 		}
 
 		let isSecret = opts?.secret ?? false;

package/src/cmd/cloud/index.ts

@@ -9,6 +9,7 @@ import { sshSubcommand } from './ssh';
 import { scpSubcommand } from './scp';
 import { deploymentCommand } from './deployment';
 import keyvalueCommand from './keyvalue';
+import queueCommand from './queue';
 import { agentCommand } from './agent';
 import envCommand from './env';
 import apikeyCommand from './apikey';
@@ -30,6 +31,7 @@ export const command = createCommand({
 	subcommands: [
 		apikeyCommand,
 		keyvalueCommand,
+		queueCommand,
 		agentCommand,
 		streamCommand,
 		vectorCommand,

package/src/cmd/cloud/queue/ack.ts

@@ -0,0 +1,50 @@
+import { z } from 'zod';
+import { createCommand } from '../../../types';
+import * as tui from '../../../tui';
+import { createQueueAPIClient, getQueueApiOptions } from './util';
+import { getCommand } from '../../../command-prefix';
+import { ackMessage } from '@agentuity/server';
+
+const AckResponseSchema = z.object({
+	success: z.boolean(),
+	queue_name: z.string(),
+	message_id: z.string(),
+});
+
+export const ackSubcommand = createCommand({
+	name: 'ack',
+	description: 'Acknowledge a message (mark as processed)',
+	tags: ['mutating', 'updates-resource', 'requires-auth'],
+	requires: { auth: true },
+	examples: [
+		{
+			command: getCommand('cloud queue ack my-queue msg-123'),
+			description: 'Acknowledge a message',
+		},
+	],
+	schema: {
+		args: z.object({
+			queue_name: z.string().min(1).describe('Queue name'),
+			message_id: z.string().min(1).describe('Message ID'),
+		}),
+		response: AckResponseSchema,
+	},
+
+	async handler(ctx) {
+		const { args, options } = ctx;
+		const client = await createQueueAPIClient(ctx);
+		await ackMessage(client, args.queue_name, args.message_id, getQueueApiOptions(ctx));
+
+		if (!options.json) {
+			tui.success(`Acknowledged message: ${args.message_id}`);
+		}
+
+		return {
+			success: true,
+			queue_name: args.queue_name,
+			message_id: args.message_id,
+		};
+	},
+});
+
+export default ackSubcommand;