@agentuity/cli 0.1.23 → 0.1.24

package/src/cmd/ai/cadence/pause.ts

@@ -0,0 +1,119 @@
+import { z } from 'zod';
+import { createCommand } from '../../../types';
+import * as tui from '../../../tui';
+import {
+	createCadenceKVAdapter,
+	CADENCE_NAMESPACE,
+	getLoopStateKey,
+	parseLoopState,
+	type CadenceLoop,
+} from './util';
+import { getCommand } from '../../../command-prefix';
+
+const CadencePauseResponseSchema = z.object({
+	success: z.boolean(),
+	loopId: z.string(),
+	previousStatus: z.string().optional(),
+	newStatus: z.string().optional(),
+	message: z.string(),
+});
+
+export const pauseSubcommand = createCommand({
+	name: 'pause',
+	description: 'Pause a running Cadence loop',
+	tags: ['mutating', 'updates-resource', 'fast', 'requires-auth'],
+	requires: { auth: true },
+	examples: [{ command: getCommand('cadence pause lp_auth_impl'), description: 'Pause a loop' }],
+	schema: {
+		args: z.object({
+			loopId: z.string().min(1).describe('The loop ID to pause'),
+		}),
+		response: CadencePauseResponseSchema,
+	},
+
+	async handler(ctx) {
+		const { args, options } = ctx;
+		const kv = await createCadenceKVAdapter(ctx);
+
+		const key = getLoopStateKey(args.loopId);
+		const result = await kv.get(CADENCE_NAMESPACE, key);
+
+		if (!result.exists || !result.data) {
+			if (!options.json) {
+				tui.error(`Loop ${args.loopId} not found.`);
+			}
+			return {
+				success: false,
+				loopId: args.loopId,
+				message: 'Loop not found',
+			};
+		}
+
+		let data: unknown;
+		if (typeof result.data === 'string') {
+			try {
+				data = JSON.parse(result.data);
+			} catch {
+				if (!options.json) {
+					tui.error(`Failed to parse loop state for ${args.loopId}`);
+				}
+				return {
+					success: false,
+					loopId: args.loopId,
+					message: 'Failed to parse loop state',
+				};
+			}
+		} else {
+			data = result.data;
+		}
+
+		const loop = parseLoopState(data);
+		if (!loop) {
+			if (!options.json) {
+				tui.error(`Invalid loop state for ${args.loopId}`);
+			}
+			return {
+				success: false,
+				loopId: args.loopId,
+				message: 'Invalid loop state',
+			};
+		}
+
+		if (loop.status !== 'running') {
+			if (!options.json) {
+				tui.warning(`Loop ${args.loopId} is not running (status: ${loop.status})`);
+			}
+			return {
+				success: false,
+				loopId: args.loopId,
+				previousStatus: loop.status,
+				message: `Cannot pause loop with status: ${loop.status}`,
+			};
+		}
+
+		// Update status to paused
+		const updatedLoop: CadenceLoop = {
+			...loop,
+			status: 'paused',
+			updatedAt: new Date().toISOString(),
+		};
+
+		await kv.set(CADENCE_NAMESPACE, key, JSON.stringify(updatedLoop), {
+			contentType: 'application/json',
+		});
+
+		if (!options.json) {
+			tui.success(`Paused loop ${args.loopId}`);
+		}
+
+		return {
+			success: true,
+			loopId: args.loopId,
+			previousStatus: 'running',
+			newStatus: 'paused',
+			message: 'Loop paused successfully',
+		};
+	},
+});
+
+export default pauseSubcommand;

package/src/cmd/ai/cadence/resume.ts

@@ -0,0 +1,124 @@
+import { z } from 'zod';
+import { createCommand } from '../../../types';
+import * as tui from '../../../tui';
+import {
+	createCadenceKVAdapter,
+	CADENCE_NAMESPACE,
+	getLoopStateKey,
+	parseLoopState,
+	type CadenceLoop,
+} from './util';
+import { getCommand } from '../../../command-prefix';
+
+const CadenceResumeResponseSchema = z.object({
+	success: z.boolean(),
+	loopId: z.string(),
+	previousStatus: z.string().optional(),
+	newStatus: z.string().optional(),
+	message: z.string(),
+});
+
+export const resumeSubcommand = createCommand({
+	name: 'resume',
+	description: 'Resume a paused Cadence loop',
+	tags: ['mutating', 'updates-resource', 'fast', 'requires-auth'],
+	requires: { auth: true },
+	examples: [
+		{ command: getCommand('cadence resume lp_auth_impl'), description: 'Resume a paused loop' },
+	],
+	schema: {
+		args: z.object({
+			loopId: z.string().min(1).describe('The loop ID to resume'),
+		}),
+		response: CadenceResumeResponseSchema,
+	},
+
+	async handler(ctx) {
+		const { args, options } = ctx;
+		const kv = await createCadenceKVAdapter(ctx);
+
+		const key = getLoopStateKey(args.loopId);
+		const result = await kv.get(CADENCE_NAMESPACE, key);
+
+		if (!result.exists || !result.data) {
+			if (!options.json) {
+				tui.error(`Loop ${args.loopId} not found.`);
+			}
+			return {
+				success: false,
+				loopId: args.loopId,
+				message: 'Loop not found',
+			};
+		}
+
+		let data: unknown;
+		if (typeof result.data === 'string') {
+			try {
+				data = JSON.parse(result.data);
+			} catch {
+				if (!options.json) {
+					tui.error(`Failed to parse loop state for ${args.loopId}`);
+				}
+				return {
+					success: false,
+					loopId: args.loopId,
+					message: 'Failed to parse loop state',
+				};
+			}
+		} else {
+			data = result.data;
+		}
+
+		const loop = parseLoopState(data);
+		if (!loop) {
+			if (!options.json) {
+				tui.error(`Invalid loop state for ${args.loopId}`);
+			}
+			return {
+				success: false,
+				loopId: args.loopId,
+				message: 'Invalid loop state',
+			};
+		}
+
+		if (loop.status !== 'paused') {
+			if (!options.json) {
+				tui.warning(`Loop ${args.loopId} is not paused (status: ${loop.status})`);
+			}
+			return {
+				success: false,
+				loopId: args.loopId,
+				previousStatus: loop.status,
+				message: `Cannot resume loop with status: ${loop.status}`,
+			};
+		}
+
+		// Update status to running
+		const updatedLoop: CadenceLoop = {
+			...loop,
+			status: 'running',
+			updatedAt: new Date().toISOString(),
+		};
+
+		await kv.set(CADENCE_NAMESPACE, key, JSON.stringify(updatedLoop), {
+			contentType: 'application/json',
+		});
+
+		if (!options.json) {
+			tui.success(`Resumed loop ${args.loopId}`);
+			tui.info(
+				'Note: The loop will continue when the Open Code session checks for status updates.'
+			);
+		}
+
+		return {
+			success: true,
+			loopId: args.loopId,
+			previousStatus: 'paused',
+			newStatus: 'running',
+			message: 'Loop resumed successfully',
+		};
+	},
+});
+
+export default resumeSubcommand;

package/src/cmd/ai/cadence/status.ts

@@ -0,0 +1,141 @@
+import { z } from 'zod';
+import { createCommand } from '../../../types';
+import * as tui from '../../../tui';
+import { createCadenceKVAdapter, CADENCE_NAMESPACE, getLoopStateKey, parseLoopState } from './util';
+import { getCommand } from '../../../command-prefix';
+
+const CadenceStatusResponseSchema = z.object({
+	found: z.boolean(),
+	loop: z
+		.object({
+			loopId: z.string(),
+			status: z.string(),
+			iteration: z.number(),
+			maxIterations: z.number(),
+			prompt: z.string(),
+			projectLabel: z.string().optional(),
+			sessionId: z.string().optional(),
+			createdAt: z.string(),
+			updatedAt: z.string(),
+			lastError: z.string().optional(),
+		})
+		.optional(),
+});
+
+export const statusSubcommand = createCommand({
+	name: 'status',
+	aliases: ['get', 'show'],
+	description: 'Get status of a Cadence loop',
+	tags: ['read-only', 'fast', 'requires-auth'],
+	requires: { auth: true },
+	examples: [
+		{ command: getCommand('cadence status lp_auth_impl'), description: 'Get loop status' },
+	],
+	schema: {
+		args: z.object({
+			loopId: z.string().min(1).describe('The loop ID (e.g., lp_auth_impl)'),
+		}),
+		response: CadenceStatusResponseSchema,
+	},
+	idempotent: true,
+
+	async handler(ctx) {
+		const { args, options } = ctx;
+		const kv = await createCadenceKVAdapter(ctx);
+
+		const key = getLoopStateKey(args.loopId);
+		const result = await kv.get(CADENCE_NAMESPACE, key);
+
+		if (!result.exists || !result.data) {
+			if (!options.json) {
+				tui.warning(`Loop ${args.loopId} not found.`);
+			}
+			return { found: false };
+		}
+
+		let data: unknown;
+		if (typeof result.data === 'string') {
+			try {
+				data = JSON.parse(result.data);
+			} catch {
+				if (!options.json) {
+					tui.error(`Failed to parse loop state for ${args.loopId}`);
+				}
+				return { found: false };
+			}
+		} else {
+			data = result.data;
+		}
+
+		const loop = parseLoopState(data);
+		if (!loop) {
+			if (!options.json) {
+				tui.error(`Invalid loop state for ${args.loopId}`);
+			}
+			return { found: false };
+		}
+
+		if (!options.json) {
+			console.log();
+			tui.info(`Cadence Loop: ${tui.colorPrimary(loop.loopId)}`);
+			console.log();
+
+			const details = [
+				['Status', formatStatus(loop.status)],
+				['Iteration', `${loop.iteration} / ${loop.maxIterations}`],
+				['Project', loop.projectLabel ?? '-'],
+				['Session', loop.sessionId ?? '-'],
+				['Created', loop.createdAt],
+				['Updated', loop.updatedAt],
+			];
+
+			if (loop.lastError) {
+				details.push(['Last Error', tui.colorError(loop.lastError)]);
+			}
+
+			for (const [label, value] of details) {
+				console.log(`  ${tui.muted(label + ':')} ${value}`);
+			}
+
+			console.log();
+			console.log(tui.muted('Task:'));
+			console.log(`  ${loop.prompt}`);
+			console.log();
+		}
+
+		return {
+			found: true,
+			loop: {
+				loopId: loop.loopId,
+				status: loop.status,
+				iteration: loop.iteration,
+				maxIterations: loop.maxIterations,
+				prompt: loop.prompt,
+				projectLabel: loop.projectLabel,
+				sessionId: loop.sessionId,
+				createdAt: loop.createdAt,
+				updatedAt: loop.updatedAt,
+				lastError: loop.lastError,
+			},
+		};
+	},
+});
+
+function formatStatus(status: string): string {
+	switch (status) {
+		case 'running':
+			return tui.colorSuccess('● running');
+		case 'paused':
+			return tui.colorWarning('⏸ paused');
+		case 'completed':
+			return tui.colorSuccess('✓ completed');
+		case 'failed':
+			return tui.colorError('✗ failed');
+		case 'cancelled':
+			return tui.muted('○ cancelled');
+		default:
+			return status;
+	}
+}
+
+export default statusSubcommand;

package/src/cmd/ai/cadence/stop.ts

@@ -0,0 +1,124 @@
+import { z } from 'zod';
+import { createCommand } from '../../../types';
+import * as tui from '../../../tui';
+import {
+	createCadenceKVAdapter,
+	CADENCE_NAMESPACE,
+	getLoopStateKey,
+	parseLoopState,
+	type CadenceLoop,
+} from './util';
+import { getCommand } from '../../../command-prefix';
+
+const CadenceStopResponseSchema = z.object({
+	success: z.boolean(),
+	loopId: z.string(),
+	previousStatus: z.string().optional(),
+	newStatus: z.string().optional(),
+	message: z.string(),
+});
+
+export const stopSubcommand = createCommand({
+	name: 'stop',
+	aliases: ['cancel'],
+	description: 'Stop and cancel a Cadence loop',
+	tags: ['mutating', 'updates-resource', 'fast', 'requires-auth'],
+	requires: { auth: true },
+	examples: [
+		{ command: getCommand('cadence stop lp_auth_impl'), description: 'Stop and cancel a loop' },
+	],
+	schema: {
+		args: z.object({
+			loopId: z.string().min(1).describe('The loop ID to stop'),
+		}),
+		response: CadenceStopResponseSchema,
+	},
+
+	async handler(ctx) {
+		const { args, options } = ctx;
+		const kv = await createCadenceKVAdapter(ctx);
+
+		const key = getLoopStateKey(args.loopId);
+		const result = await kv.get(CADENCE_NAMESPACE, key);
+
+		if (!result.exists || !result.data) {
+			if (!options.json) {
+				tui.error(`Loop ${args.loopId} not found.`);
+			}
+			return {
+				success: false,
+				loopId: args.loopId,
+				message: 'Loop not found',
+			};
+		}
+
+		let data: unknown;
+		if (typeof result.data === 'string') {
+			try {
+				data = JSON.parse(result.data);
+			} catch {
+				if (!options.json) {
+					tui.error(`Failed to parse loop state for ${args.loopId}`);
+				}
+				return {
+					success: false,
+					loopId: args.loopId,
+					message: 'Failed to parse loop state',
+				};
+			}
+		} else {
+			data = result.data;
+		}
+
+		const loop = parseLoopState(data);
+		if (!loop) {
+			if (!options.json) {
+				tui.error(`Invalid loop state for ${args.loopId}`);
+			}
+			return {
+				success: false,
+				loopId: args.loopId,
+				message: 'Invalid loop state',
+			};
+		}
+
+		const previousStatus = loop.status;
+
+		if (loop.status === 'completed' || loop.status === 'cancelled') {
+			if (!options.json) {
+				tui.warning(`Loop ${args.loopId} is already ${loop.status}`);
+			}
+			return {
+				success: false,
+				loopId: args.loopId,
+				previousStatus,
+				message: `Loop is already ${loop.status}`,
+			};
+		}
+
+		// Update status to cancelled
+		const updatedLoop: CadenceLoop = {
+			...loop,
+			status: 'cancelled',
+			updatedAt: new Date().toISOString(),
+		};
+
+		await kv.set(CADENCE_NAMESPACE, key, JSON.stringify(updatedLoop), {
+			contentType: 'application/json',
+		});
+
+		if (!options.json) {
+			tui.success(`Stopped loop ${args.loopId}`);
+		}
+
+		return {
+			success: true,
+			loopId: args.loopId,
+			previousStatus,
+			newStatus: 'cancelled',
+			message: 'Loop cancelled successfully',
+		};
+	},
+});
+
+export default stopSubcommand;

package/src/cmd/ai/cadence/util.ts

@@ -0,0 +1,86 @@
+import { KeyValueStorageService, type Logger } from '@agentuity/core';
+import { createServerFetchAdapter, getServiceUrls } from '@agentuity/server';
+import { getDefaultRegion } from '../../../config';
+import type { AuthData, Config } from '../../../types';
+
+/** KV namespace for Cadence loop state */
+export const CADENCE_NAMESPACE = 'agentuity-opencode-tasks';
+
+/** Prefix for loop state keys */
+export const LOOP_KEY_PREFIX = 'loop:';
+
+export interface CadenceLoop {
+	loopId: string;
+	parentId?: string;
+	projectLabel?: string;
+	sessionId?: string;
+	status: 'running' | 'paused' | 'completed' | 'failed' | 'cancelled';
+	iteration: number;
+	maxIterations: number;
+	prompt: string;
+	createdAt: string;
+	updatedAt: string;
+	lastError?: string;
+	sandbox?: {
+		mode: 'off' | 'per_iteration' | 'persistent';
+		sandboxId?: string;
+	};
+}
+
+export interface CadenceContext {
+	logger: Logger;
+	config: Config | null;
+	auth: AuthData;
+	project?: { region: string };
+}
+
+/**
+ * Creates a KV storage service for Cadence operations.
+ */
+export async function createCadenceKVAdapter(ctx: CadenceContext): Promise<KeyValueStorageService> {
+	const adapter = createServerFetchAdapter(
+		{
+			headers: {
+				Authorization: `Bearer ${ctx.auth.apiKey}`,
+			},
+		},
+		ctx.logger
+	);
+
+	const region = ctx.project?.region || (await getDefaultRegion(ctx.config?.name, ctx.config));
+	const urls = getServiceUrls(region);
+	const baseUrl = urls.catalyst;
+	return new KeyValueStorageService(baseUrl, adapter);
+}
+
+/**
+ * Gets the state key for a loop.
+ */
+export function getLoopStateKey(loopId: string): string {
+	return `${LOOP_KEY_PREFIX}${loopId}:state`;
+}
+
+/**
+ * Parses a loop state from KV storage.
+ */
+export function parseLoopState(data: unknown): CadenceLoop | null {
+	if (!data || typeof data !== 'object') return null;
+
+	const loop = data as Record<string, unknown>;
+	if (!loop.loopId || !loop.status || !loop.prompt) return null;
+
+	return {
+		loopId: String(loop.loopId),
+		parentId: loop.parentId ? String(loop.parentId) : undefined,
+		projectLabel: loop.projectLabel ? String(loop.projectLabel) : undefined,
+		sessionId: loop.sessionId ? String(loop.sessionId) : undefined,
+		status: loop.status as CadenceLoop['status'],
+		iteration: Number(loop.iteration) || 1,
+		maxIterations: Number(loop.maxIterations) || 50,
+		prompt: String(loop.prompt),
+		createdAt: String(loop.createdAt),
+		updatedAt: String(loop.updatedAt),
+		lastError: loop.lastError ? String(loop.lastError) : undefined,
+		sandbox: loop.sandbox as CadenceLoop['sandbox'],
+	};
+}

package/src/cmd/ai/index.ts

@@ -1,4 +1,5 @@
 import { createCommand } from '../../types';
+import cadenceCommand from './cadence';
 import capabilitiesCommand from './capabilities';
 import promptCommand from './prompt';
 import schemaCommand from './schema';
@@ -29,5 +30,5 @@ export const command = createCommand({
 			description: 'Generate Agent Skills from CLI schema',
 		},
 	],
-	subcommands: [opencodeCommand, capabilitiesCommand, promptCommand, schemaCommand, skillsCommand],
+	subcommands: [opencodeCommand, cadenceCommand, capabilitiesCommand, promptCommand, schemaCommand, skillsCommand],
 });

package/src/cmd/auth/machine/setup.ts

@@ -15,7 +15,7 @@ export const setupSubcommand = createSubcommand({
 	name: 'setup',
 	description:
 		'Set up machine authentication by uploading a public key for self-hosted infrastructure',
-	tags: ['mutating', 'slow', 'requires-auth'],
+	tags: ['mutating', 'slow', 'requires-auth', 'uses-stdin'],
 	examples: [
 		{
 			command: `${getCommand('auth machine setup')} --file ./public-key.pem`,

package/src/cmd/auth/ssh/add.ts

@@ -115,7 +115,7 @@ export const addCommand = createSubcommand({
 	name: 'add',
 	aliases: ['create'],
 	description: 'Add an SSH public key to your account (reads from file or stdin)',
-	tags: ['mutating', 'creates-resource', 'slow', 'requires-auth'],
+	tags: ['mutating', 'creates-resource', 'slow', 'requires-auth', 'uses-stdin'],
 	idempotent: false,
 	requires: { apiClient: true, auth: true },
 	examples: [