@agentuity/cli 1.0.22 → 1.0.23

package/src/cmd/cloud/email/destination/schemas.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+
+export const DestinationSchema = z.object({
+	id: z.string(),
+	type: z.string(),
+	config: z.record(z.string(), z.unknown()).optional(),
+	created_at: z.string(),
+	updated_at: z.string().optional(),
+});

package/src/cmd/cloud/email/destination/url.ts

@@ -0,0 +1,75 @@
+import { z } from 'zod';
+import { createCommand } from '../../../../types';
+import * as tui from '../../../../tui';
+import { setResourceInfo } from '../../../../cache';
+import { createEmailAdapter, resolveEmailOrgId, resolveEmailRegion } from '../util';
+import { DestinationSchema } from './schemas';
+
+export const urlSubcommand = createCommand({
+	name: 'url',
+	description: 'Add a URL destination to an email address',
+	tags: ['mutating', 'creates-resource', 'requires-auth'],
+	requires: { auth: true },
+	schema: {
+		args: z.object({
+			address_id: z.string().min(1).describe('Email address ID (eaddr_*)'),
+			url: z
+				.string()
+				.url()
+				.refine((u) => /^https?:\/\//i.test(u), {
+					message: 'URL must use http or https protocol',
+				})
+				.describe('Destination webhook URL'),
+		}),
+		options: z.object({
+			method: z
+				.enum(['POST', 'PUT', 'PATCH'])
+				.optional()
+				.default('POST')
+				.describe('HTTP method (default: POST)'),
+		}),
+		response: DestinationSchema,
+	},
+
+	async handler(ctx) {
+		const { args, opts, options, config } = ctx;
+
+		const destinationConfig: Record<string, unknown> = {
+			url: args.url,
+		};
+		if (opts.method && opts.method !== 'POST') {
+			destinationConfig.method = opts.method;
+		}
+
+		const email = createEmailAdapter(ctx);
+		const destination = await email.createDestination(args.address_id, 'url', destinationConfig);
+
+		const profileName = config?.name ?? 'production';
+		const orgId = resolveEmailOrgId(ctx);
+		const region = resolveEmailRegion(ctx);
+		setResourceInfo('email', profileName, destination.id, region, orgId).catch(() => {
+			// Non-blocking: destination was already created successfully
+		});
+
+		if (!options.json) {
+			tui.success(`Destination created: ${tui.bold(destination.id)}`);
+			tui.table(
+				[
+					{
+						ID: destination.id,
+						Type: 'url',
+						URL: args.url,
+						Method: opts.method ?? 'POST',
+						Created: new Date(destination.created_at).toLocaleString(),
+					},
+				],
+				['ID', 'Type', 'URL', 'Method', 'Created'],
+				{ layout: 'vertical', padStart: '  ' }
+			);
+		}
+
+		return destination;
+	},
+});
+
+export default urlSubcommand;

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

@@ -0,0 +1,52 @@
+import { z } from 'zod';
+import { createCommand } from '../../../types';
+import * as tui from '../../../tui';
+import { createEmailAdapter, EmailAddressSchema } from './util';
+
+export const getSubcommand = createCommand({
+	name: 'get',
+	description: 'Get an email address by ID',
+	tags: ['read-only', 'requires-auth'],
+	requires: { auth: true },
+	schema: {
+		args: z.object({
+			id: z.string().min(1).describe('Email address ID (eaddr_*)'),
+		}),
+		response: EmailAddressSchema,
+	},
+
+	async handler(ctx) {
+		const { args, options } = ctx;
+		const email = createEmailAdapter(ctx);
+		const address = await email.getAddress(args.id);
+
+		if (!address) {
+			tui.fatal(`Email address not found: ${args.id}`);
+		}
+
+		if (!options.json) {
+			tui.success(`Email Address: ${tui.bold(address.email)}`);
+			tui.table(
+				[
+					{
+						ID: address.id,
+						Email: address.email,
+						Project: address.project_id ?? '-',
+						Provider: address.provider ?? '-',
+						Config: address.config ? JSON.stringify(address.config) : '-',
+						Created: new Date(address.created_at).toLocaleString(),
+						Updated: address.updated_at
+							? new Date(address.updated_at).toLocaleString()
+							: '-',
+					},
+				],
+				['ID', 'Email', 'Project', 'Provider', 'Config', 'Created', 'Updated'],
+				{ layout: 'vertical', padStart: '  ' }
+			);
+		}
+
+		return address;
+	},
+});
+
+export default getSubcommand;

package/src/cmd/cloud/email/inbound/get.ts

@@ -0,0 +1,53 @@
+import { z } from 'zod';
+import { createCommand } from '../../../../types';
+import * as tui from '../../../../tui';
+import { createEmailAdapter, truncate } from '../util';
+import { EmailInboundSchema } from './schemas';
+
+export const getSubcommand = createCommand({
+	name: 'get',
+	description: 'Get a received email by ID',
+	tags: ['read-only', 'requires-auth'],
+	requires: { auth: true },
+	schema: {
+		args: z.object({
+			id: z.string().min(1).describe('Inbound email ID (ein_*)'),
+		}),
+		response: EmailInboundSchema,
+	},
+
+	async handler(ctx) {
+		const { args, options } = ctx;
+		const email = createEmailAdapter(ctx);
+		const inbound = await email.getInbound(args.id);
+
+		if (!inbound) {
+			tui.fatal(`Inbound email not found: ${args.id}`);
+		}
+
+		if (!options.json) {
+			tui.success(`Inbound Email: ${tui.bold(inbound.id)}`);
+			tui.table(
+				[
+					{
+						ID: inbound.id,
+						From: inbound.from,
+						To: inbound.to,
+						Subject: inbound.subject ?? '-',
+						Text: truncate(inbound.text),
+						Status: inbound.status ?? '-',
+						Received: inbound.received_at
+							? new Date(inbound.received_at).toLocaleString()
+							: '-',
+					},
+				],
+				['ID', 'From', 'To', 'Subject', 'Text', 'Status', 'Received'],
+				{ layout: 'vertical', padStart: '  ' }
+			);
+		}
+
+		return inbound;
+	},
+});
+
+export default getSubcommand;

package/src/cmd/cloud/email/inbound/index.ts

@@ -0,0 +1,13 @@
+import { createCommand } from '../../../../types';
+import { listSubcommand } from './list';
+import { getSubcommand } from './get';
+
+export const inboundCommand = createCommand({
+	name: 'inbound',
+	description: 'Manage inbound (received) emails',
+	tags: ['requires-auth'],
+	requires: { auth: true },
+	subcommands: [listSubcommand, getSubcommand],
+});
+
+export default inboundCommand;

package/src/cmd/cloud/email/inbound/list.ts

@@ -0,0 +1,50 @@
+import { z } from 'zod';
+import { createCommand } from '../../../../types';
+import * as tui from '../../../../tui';
+import { createEmailAdapter } from '../util';
+import { EmailInboundSchema } from './schemas';
+
+export const listSubcommand = createCommand({
+	name: 'list',
+	aliases: ['ls'],
+	description: 'List received emails',
+	tags: ['read-only', 'requires-auth'],
+	requires: { auth: true },
+	schema: {
+		options: z.object({
+			addressId: z.string().optional().describe('Filter by email address ID'),
+		}),
+		response: z.array(EmailInboundSchema),
+	},
+
+	async handler(ctx) {
+		const { opts, options } = ctx;
+		const email = createEmailAdapter(ctx);
+		const inbound = await email.listInbound(opts.addressId);
+
+		if (!options.json) {
+			tui.table(
+				inbound.map((item) => ({
+					ID: item.id,
+					From: item.from,
+					To: item.to,
+					Subject: item.subject ?? '-',
+					Status: item.status ?? '-',
+					Received: item.received_at ? new Date(item.received_at).toLocaleString() : '-',
+				})),
+				[
+					{ name: 'ID', alignment: 'left' },
+					{ name: 'From', alignment: 'left' },
+					{ name: 'To', alignment: 'left' },
+					{ name: 'Subject', alignment: 'left' },
+					{ name: 'Status', alignment: 'left' },
+					{ name: 'Received', alignment: 'left' },
+				]
+			);
+		}
+
+		return inbound;
+	},
+});
+
+export default listSubcommand;

package/src/cmd/cloud/email/inbound/schemas.ts

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+
+export const EmailInboundSchema = z.object({
+	id: z.string(),
+	from: z.string(),
+	to: z.string(),
+	subject: z.string().optional(),
+	text: z.string().optional(),
+	status: z.string().optional(),
+	received_at: z.string().optional(),
+});

package/src/cmd/cloud/email/index.ts

@@ -0,0 +1,29 @@
+import { createCommand } from '../../../types';
+import { createSubcommand } from './create';
+import { listSubcommand } from './list';
+import { getSubcommand } from './get';
+import { deleteSubcommand } from './delete';
+import { destinationCommand } from './destination';
+import { sendSubcommand } from './send';
+import { inboundCommand } from './inbound';
+import { outboundCommand } from './outbound';
+
+export const emailCommand = createCommand({
+	name: 'email',
+	aliases: ['mail'],
+	description: 'Manage email addresses and messages',
+	tags: ['requires-auth'],
+	subcommands: [
+		createSubcommand,
+		listSubcommand,
+		getSubcommand,
+		deleteSubcommand,
+		destinationCommand,
+		sendSubcommand,
+		inboundCommand,
+		outboundCommand,
+	],
+	requires: { auth: true },
+});
+
+export default emailCommand;

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

@@ -0,0 +1,44 @@
+import { z } from 'zod';
+import { createCommand } from '../../../types';
+import * as tui from '../../../tui';
+import { createEmailAdapter, EmailAddressSchema } from './util';
+
+export const listSubcommand = createCommand({
+	name: 'list',
+	aliases: ['ls'],
+	description: 'List email addresses',
+	tags: ['read-only', 'requires-auth'],
+	requires: { auth: true },
+	schema: {
+		response: z.array(EmailAddressSchema),
+	},
+
+	async handler(ctx) {
+		const { options } = ctx;
+		const email = createEmailAdapter(ctx);
+		const addresses = await email.listAddresses();
+
+		if (!options.json) {
+			tui.table(
+				addresses.map((item) => ({
+					ID: item.id,
+					Email: item.email,
+					Project: item.project_id ?? '-',
+					Provider: item.provider ?? '-',
+					Created: new Date(item.created_at).toLocaleString(),
+				})),
+				[
+					{ name: 'ID', alignment: 'left' },
+					{ name: 'Email', alignment: 'left' },
+					{ name: 'Project', alignment: 'left' },
+					{ name: 'Provider', alignment: 'left' },
+					{ name: 'Created', alignment: 'left' },
+				]
+			);
+		}
+
+		return addresses;
+	},
+});
+
+export default listSubcommand;

package/src/cmd/cloud/email/outbound/get.ts

@@ -0,0 +1,54 @@
+import { z } from 'zod';
+import { createCommand } from '../../../../types';
+import * as tui from '../../../../tui';
+import { createEmailAdapter, truncate } from '../util';
+import { EmailOutboundSchema } from './schemas';
+
+export const getSubcommand = createCommand({
+	name: 'get',
+	description: 'Get a sent email by ID',
+	tags: ['read-only', 'requires-auth'],
+	requires: { auth: true },
+	schema: {
+		args: z.object({
+			id: z.string().min(1).describe('Outbound email ID (eout_*)'),
+		}),
+		response: EmailOutboundSchema,
+	},
+
+	async handler(ctx) {
+		const { args, options } = ctx;
+		const email = createEmailAdapter(ctx);
+		const outbound = await email.getOutbound(args.id);
+
+		if (!outbound) {
+			tui.fatal(`Outbound email not found: ${args.id}`);
+		}
+
+		if (!options.json) {
+			tui.success(`Outbound Email: ${tui.bold(outbound.id)}`);
+			tui.table(
+				[
+					{
+						ID: outbound.id,
+						From: outbound.from,
+						To: outbound.to,
+						Subject: outbound.subject ?? '-',
+						Text: truncate(outbound.text),
+						Status: outbound.status ?? '-',
+						Error: outbound.error ?? '-',
+						Sent: outbound.sent_at
+							? new Date(outbound.sent_at).toLocaleString()
+							: '-',
+					},
+				],
+				['ID', 'From', 'To', 'Subject', 'Text', 'Status', 'Error', 'Sent'],
+				{ layout: 'vertical', padStart: '  ' }
+			);
+		}
+
+		return outbound;
+	},
+});
+
+export default getSubcommand;

package/src/cmd/cloud/email/outbound/index.ts

@@ -0,0 +1,13 @@
+import { createCommand } from '../../../../types';
+import { listSubcommand } from './list';
+import { getSubcommand } from './get';
+
+export const outboundCommand = createCommand({
+	name: 'outbound',
+	description: 'Manage outbound (sent) emails',
+	tags: ['requires-auth'],
+	requires: { auth: true },
+	subcommands: [listSubcommand, getSubcommand],
+});
+
+export default outboundCommand;

package/src/cmd/cloud/email/outbound/list.ts

@@ -0,0 +1,50 @@
+import { z } from 'zod';
+import { createCommand } from '../../../../types';
+import * as tui from '../../../../tui';
+import { createEmailAdapter } from '../util';
+import { EmailOutboundSchema } from './schemas';
+
+export const listSubcommand = createCommand({
+	name: 'list',
+	aliases: ['ls'],
+	description: 'List sent emails',
+	tags: ['read-only', 'requires-auth'],
+	requires: { auth: true },
+	schema: {
+		options: z.object({
+			addressId: z.string().optional().describe('Filter by email address ID'),
+		}),
+		response: z.array(EmailOutboundSchema),
+	},
+
+	async handler(ctx) {
+		const { opts, options } = ctx;
+		const email = createEmailAdapter(ctx);
+		const outbound = await email.listOutbound(opts.addressId);
+
+		if (!options.json) {
+			tui.table(
+				outbound.map((item) => ({
+					ID: item.id,
+					From: item.from,
+					To: item.to,
+					Subject: item.subject ?? '-',
+					Status: item.status ?? '-',
+					Sent: item.sent_at ? new Date(item.sent_at).toLocaleString() : '-',
+				})),
+				[
+					{ name: 'ID', alignment: 'left' },
+					{ name: 'From', alignment: 'left' },
+					{ name: 'To', alignment: 'left' },
+					{ name: 'Subject', alignment: 'left' },
+					{ name: 'Status', alignment: 'left' },
+					{ name: 'Sent', alignment: 'left' },
+				]
+			);
+		}
+
+		return outbound;
+	},
+});
+
+export default listSubcommand;

package/src/cmd/cloud/email/outbound/schemas.ts

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+
+export const EmailOutboundSchema = z.object({
+	id: z.string(),
+	from: z.string(),
+	to: z.string(),
+	subject: z.string().optional(),
+	text: z.string().optional(),
+	html: z.string().optional(),
+	status: z.string().optional(),
+	error: z.string().optional(),
+	sent_at: z.string().optional(),
+	created_at: z.string().optional(),
+	updated_at: z.string().optional(),
+});

package/src/cmd/cloud/email/send.ts

@@ -0,0 +1,91 @@
+import { basename } from 'node:path';
+import { z } from 'zod';
+import type { EmailAttachment } from '@agentuity/core';
+import { createCommand } from '../../../types';
+import * as tui from '../../../tui';
+import { createEmailAdapter, truncate } from './util';
+import { EmailOutboundSchema } from './outbound/schemas';
+
+export const sendSubcommand = createCommand({
+	name: 'send',
+	description: 'Send an email',
+	tags: ['mutating', 'requires-auth'],
+	requires: { auth: true },
+	schema: {
+		args: z.object({
+			to: z.string().email().describe('Destination email address'),
+		}),
+		options: z.object({
+			from: z.string().email().describe('Sender email address (must be owned by org)'),
+			subject: z.string().min(1).describe('Email subject'),
+			text: z.string().optional().describe('Plain text body'),
+			html: z.string().optional().describe('HTML body'),
+			file: z.array(z.string()).optional().describe('Attachment file path (repeatable)'),
+		}),
+		response: EmailOutboundSchema,
+	},
+
+	async handler(ctx) {
+		const { args, opts, options } = ctx;
+
+		if (!opts.text && !opts.html) {
+			tui.fatal('At least one of --text or --html is required');
+		}
+
+		const fileValues = Array.isArray(opts.file)
+			? opts.file
+			: opts.file
+				? [opts.file]
+				: [];
+
+		const attachments: EmailAttachment[] = [];
+		for (const filePath of fileValues) {
+			const file = Bun.file(filePath);
+			if (!(await file.exists())) {
+				tui.fatal(`Attachment file not found: ${filePath}`);
+			}
+
+			const buffer = Buffer.from(await file.arrayBuffer());
+			attachments.push({
+				filename: basename(filePath),
+				contentType: file.type || 'application/octet-stream',
+				content: buffer.toString('base64'),
+			});
+		}
+
+		const email = createEmailAdapter(ctx);
+		const outbound = await email.send({
+			to: [args.to],
+			from: opts.from,
+			subject: opts.subject,
+			text: opts.text,
+			html: opts.html,
+			attachments: attachments.length > 0 ? attachments : undefined,
+		});
+
+		if (!options.json) {
+			tui.success('Email queued for delivery');
+			tui.table(
+				[
+					{
+						ID: outbound.id,
+						From: outbound.from,
+						To: outbound.to,
+						Subject: outbound.subject ?? '-',
+						Text: truncate(outbound.text),
+						Status: outbound.status ?? '-',
+						Sent: outbound.sent_at
+							? new Date(outbound.sent_at).toLocaleString()
+							: '-',
+					},
+				],
+				['ID', 'From', 'To', 'Subject', 'Text', 'Status', 'Sent'],
+				{ layout: 'vertical', padStart: '  ' }
+			);
+		}
+
+		return outbound;
+	},
+});
+
+export default sendSubcommand;

package/src/cmd/cloud/email/util.ts

@@ -0,0 +1,89 @@
+import { z } from 'zod';
+import { EmailStorageService, type Logger } from '@agentuity/core';
+import { createServerFetchAdapter } from '@agentuity/server';
+import type { AuthData, Config, GlobalOptions, ProjectConfig } from '../../../types';
+import { getCatalystUrl } from '../../../catalyst';
+import * as tui from '../../../tui';
+
+export type {
+	EmailAddress,
+	EmailDestination,
+	EmailInbound,
+	EmailOutbound,
+	EmailAttachment,
+	EmailSendParams,
+} from '@agentuity/core';
+
+interface EmailContext {
+	logger: Logger;
+	auth: AuthData;
+	region?: string;
+	project?: ProjectConfig;
+	config: Config | null;
+	options: GlobalOptions;
+}
+
+export function resolveEmailOrgId(ctx: EmailContext, explicitOrgId?: string): string {
+	const orgId =
+		explicitOrgId ??
+		ctx.project?.orgId ??
+		ctx.options.orgId ??
+		(process.env.AGENTUITY_CLOUD_ORG_ID || ctx.config?.preferences?.orgId);
+
+	if (!orgId) {
+		tui.fatal(
+			'Organization ID is required. Either run from a project directory or use --org-id flag.'
+		);
+	}
+
+	return orgId;
+}
+
+export function resolveEmailRegion(ctx: EmailContext): string {
+	if (ctx.region) {
+		return ctx.region;
+	}
+	if (process.env.AGENTUITY_REGION) {
+		return process.env.AGENTUITY_REGION;
+	}
+	if (ctx.config?.name === 'local') {
+		return 'local';
+	}
+	if (ctx.config?.preferences?.region) {
+		return ctx.config.preferences.region;
+	}
+	return 'usc';
+}
+
+export const EmailAddressSchema = z.object({
+	id: z.string(),
+	email: z.string(),
+	project_id: z.string().optional(),
+	provider: z.string().optional(),
+	config: z.record(z.string(), z.unknown()).optional(),
+	created_at: z.string(),
+	updated_at: z.string().optional(),
+});
+
+export function truncate(value: string | undefined, length = 200): string {
+	if (!value) {
+		return '-';
+	}
+	return value.length > length ? `${value.slice(0, length - 3)}...` : value;
+}
+
+export function createEmailAdapter(ctx: EmailContext, explicitOrgId?: string) {
+	const orgId = resolveEmailOrgId(ctx, explicitOrgId);
+	const adapter = createServerFetchAdapter(
+		{
+			headers: {
+				Authorization: `Bearer ${ctx.auth.apiKey}`,
+				'x-agentuity-orgid': orgId,
+			},
+		},
+		ctx.logger
+	);
+
+	const baseUrl = getCatalystUrl(resolveEmailRegion(ctx));
+	return new EmailStorageService(baseUrl, adapter);
+}

package/src/cmd/cloud/index.ts

@@ -10,12 +10,16 @@ import { scpSubcommand } from './scp';
 import { deploymentCommand } from './deployment';
 import keyvalueCommand from './keyvalue';
 import queueCommand from './queue';
+import webhookCommand from './webhook';
 import { agentCommand } from './agent';
 import envCommand from './env';
 import apikeyCommand from './apikey';
 import streamCommand from './stream';
 import vectorCommand from './vector';
+import { emailCommand } from './email';
+import taskCommand from './task';
 import sandboxCommand from './sandbox';
+import scheduleCommand from './schedule';
 import { regionSubcommand } from './region';
 import { machineCommand } from './machine';
 import { evalCommand } from './eval';
@@ -35,10 +39,14 @@ export const command = createCommand({
 		apikeyCommand,
 		keyvalueCommand,
 		queueCommand,
+		webhookCommand,
+		taskCommand,
 		agentCommand,
 		streamCommand,
+		emailCommand,
 		vectorCommand,
 		sandboxCommand,
+		scheduleCommand,
 		envCommand,
 		evalCommand,
 		evalRunCommand,