@agentuity/server 1.0.31 → 1.0.33

package/src/api/project/env-update.ts

@@ -1,55 +0,0 @@
-import { z } from 'zod';
-import { type APIClient, APIResponseSchema } from '../api.ts';
-import type { Project } from './get.ts';
-import { projectGet } from './get.ts';
-import { ProjectResponseError } from './util.ts';
-
-export const ProjectEnvUpdateRequestSchema = z.object({
-	id: z.string().describe('the project id'),
-	env: z.record(z.string(), z.string()).optional().describe('environment variables to set/update'),
-	secrets: z.record(z.string(), z.string()).optional().describe('secrets to set/update'),
-});
-
-export const ProjectEnvUpdateResponseSchema = APIResponseSchema(
-	z
-		.object({
-			id: z.string().describe('the project id'),
-			orgId: z.string().describe('the organization id'),
-			api_key: z.string().optional().describe('the SDK api key for the project'),
-			env: z.record(z.string(), z.string()).optional().describe('the environment key/values'),
-			secrets: z.record(z.string(), z.string()).optional().describe('the secrets key/values'),
-		})
-		.optional()
-);
-
-type ProjectEnvUpdateRequest = z.infer<typeof ProjectEnvUpdateRequestSchema>;
-type ProjectEnvUpdateResponse = z.infer<typeof ProjectEnvUpdateResponseSchema>;
-
-/**
- * Update environment variables and/or secrets for a project.
- * This will merge the provided env/secrets with existing values.
- * Keys starting with 'AGENTUITY_' should be filtered out before calling this function.
- */
-export async function projectEnvUpdate(
-	client: APIClient,
-	request: ProjectEnvUpdateRequest
-): Promise<Project> {
-	const { id, env, secrets } = request;
-
-	const resp = await client.request<ProjectEnvUpdateResponse, Omit<ProjectEnvUpdateRequest, 'id'>>(
-		'PUT',
-		`/cli/project/${id}/env`,
-		ProjectEnvUpdateResponseSchema,
-		{
-			env,
-			secrets,
-		}
-	);
-
-	if (!resp.success) {
-		throw new ProjectResponseError({ message: resp.message ?? 'failed to update project env' });
-	}
-
-	// Fetch the updated project to ensure we have complete data including name
-	return projectGet(client, { id, mask: false });
-}

package/src/api/project/exists.ts

@@ -1,58 +0,0 @@
-import { z } from 'zod';
-import { type APIClient, APIError, APIResponseSchema } from '../api.ts';
-import { ProjectResponseError } from './util.ts';
-
-export const ProjectExistsRequestSchema = z.object({
-	name: z.string().max(255).min(1).describe('the name of the new project'),
-	organization_id: z
-		.string()
-		.max(255)
-		.min(1)
-		.describe('the organization id to create the project in'),
-});
-
-export const ProjectExistsResponseSchema = APIResponseSchema(z.boolean());
-
-export type ProjectExistsRequest = z.infer<typeof ProjectExistsRequestSchema>;
-export type ProjectExistsResponse = z.infer<typeof ProjectExistsResponseSchema>;
-
-/**
- * Check if a project exists by name within an organization
- *
- * @param client
- * @param body
- * @returns
- */
-export async function projectExists(
-	client: APIClient,
-	body: ProjectExistsRequest
-): Promise<boolean> {
-	const qs = new URLSearchParams();
-	qs.set('orgId', body.organization_id);
-	try {
-		const resp = await client.request<ProjectExistsResponse, ProjectExistsRequest>(
-			'GET',
-			`/cli/project/exists/${encodeURIComponent(body.name)}?${qs.toString()}`,
-			ProjectExistsResponseSchema
-		);
-
-		if (resp.success) {
-			return resp.data;
-		}
-
-		return false;
-	} catch (ex) {
-		const _ex = ex as Error;
-		if (_ex instanceof APIError) {
-			switch (_ex.status) {
-				case 409:
-					return true;
-				case 422:
-					return false;
-				default:
-					break;
-			}
-		}
-		throw new ProjectResponseError({ cause: ex });
-	}
-}

package/src/api/project/hostname.ts

@@ -1,73 +0,0 @@
-import { z } from 'zod';
-import { type APIClient, APIResponseSchema } from '../api.ts';
-import { ProjectResponseError } from './util.ts';
-
-// --- GET hostname ---
-
-export const ProjectHostnameGetRequestSchema = z.object({
-	projectId: z.string().describe('the project id'),
-});
-
-const HostnameGetDataSchema = z.object({
-	hostname: z.string().nullable(),
-	url: z.string().nullable(),
-});
-
-const ProjectHostnameGetResponseSchema = APIResponseSchema(HostnameGetDataSchema);
-
-type ProjectHostnameGetRequest = z.infer<typeof ProjectHostnameGetRequestSchema>;
-type ProjectHostnameGetResponse = z.infer<typeof ProjectHostnameGetResponseSchema>;
-
-export type ProjectHostnameGetResult = z.infer<typeof HostnameGetDataSchema>;
-
-export async function projectHostnameGet(
-	client: APIClient,
-	request: ProjectHostnameGetRequest
-): Promise<ProjectHostnameGetResult> {
-	const resp = await client.get<ProjectHostnameGetResponse>(
-		`/cli/project/${request.projectId}/hostname`,
-		ProjectHostnameGetResponseSchema
-	);
-
-	if (resp.success) {
-		return resp.data;
-	}
-
-	throw new ProjectResponseError({ message: resp.message });
-}
-
-// --- SET hostname ---
-
-export const ProjectHostnameSetRequestSchema = z.object({
-	projectId: z.string().describe('the project id'),
-	hostname: z.string().describe('the vanity hostname to set'),
-});
-
-const HostnameSetDataSchema = z.object({
-	hostname: z.string(),
-	url: z.string(),
-});
-
-const ProjectHostnameSetResponseSchema = APIResponseSchema(HostnameSetDataSchema);
-
-type ProjectHostnameSetRequest = z.infer<typeof ProjectHostnameSetRequestSchema>;
-type ProjectHostnameSetResponse = z.infer<typeof ProjectHostnameSetResponseSchema>;
-
-export type ProjectHostnameSetResult = z.infer<typeof HostnameSetDataSchema>;
-
-export async function projectHostnameSet(
-	client: APIClient,
-	request: ProjectHostnameSetRequest
-): Promise<ProjectHostnameSetResult> {
-	const resp = await client.put<ProjectHostnameSetResponse>(
-		`/cli/project/${request.projectId}/hostname`,
-		{ hostname: request.hostname },
-		ProjectHostnameSetResponseSchema
-	);
-
-	if (resp.success) {
-		return resp.data;
-	}
-
-	throw new ProjectResponseError({ message: resp.message });
-}

package/src/api/project/index.ts

@@ -1,13 +0,0 @@
-export * from './agent.ts';
-export * from './create.ts';
-export * from './delete.ts';
-export * from './deploy.ts';
-export * from './deployment.ts';
-export * from './env-delete.ts';
-export * from './env-update.ts';
-export * from './exists.ts';
-export * from './get.ts';
-export * from './hostname.ts';
-export * from './list.ts';
-export * from './malware.ts';
-export * from './update-region.ts';

package/src/api/project/update-region.ts

@@ -1,44 +0,0 @@
-import { z } from 'zod';
-import { type APIClient, APIResponseSchema } from '../api.ts';
-import { ProjectResponseError } from './util.ts';
-
-export const UpdateRegionRequestSchema = z.object({
-	cloudRegion: z.string().describe('the cloud region to update the project to'),
-});
-
-export const UpdateRegionResponseSchema = APIResponseSchema(
-	z.object({
-		id: z.string().describe('the project id'),
-	})
-);
-
-type UpdateRegionRequest = z.infer<typeof UpdateRegionRequestSchema>;
-type UpdateRegionResponse = z.infer<typeof UpdateRegionResponseSchema>;
-
-/**
- * Update a project's cloud region
- *
- * @param client - The API client
- * @param projectId - The project id to update
- * @param region - The new cloud region
- * @returns The project id on success
- */
-export async function projectUpdateRegion(
-	client: APIClient,
-	projectId: string,
-	region: string
-): Promise<{ id: string }> {
-	const resp = await client.request<UpdateRegionResponse, UpdateRegionRequest>(
-		'PATCH',
-		`/cli/project/${projectId}`,
-		UpdateRegionResponseSchema,
-		{ cloudRegion: region },
-		UpdateRegionRequestSchema
-	);
-
-	if (resp.success) {
-		return resp.data;
-	}
-
-	throw new ProjectResponseError({ message: resp.message ?? 'failed to update project region' });
-}

package/src/api/project/util.ts

@@ -1,8 +0,0 @@
-import { StructuredError } from '@agentuity/core';
-
-export const ProjectResponseError = StructuredError('ProjectResponseError');
-export const ProjectNotFoundError = StructuredError('ProjectNotFoundError')<{ id: string }>();
-export const AgentNotFoundError = StructuredError('AgentNotFoundError')<{ id: string }>();
-export const MalwareCheckError = StructuredError('MalwareCheckError')<{
-	deploymentId: string;
-}>();

package/src/api/queue/analytics.ts

@@ -1,311 +0,0 @@
-import { z } from 'zod';
-import { type APIClient, APIResponseSchema } from '../api.ts';
-import {
-	type AnalyticsOptions,
-	type OrgAnalytics,
-	OrgAnalyticsSchema,
-	type QueueAnalytics,
-	QueueAnalyticsSchema,
-	type SSEStatsEvent,
-	SSEStatsEventSchema,
-	type StreamAnalyticsOptions,
-	type TimeSeriesData,
-	TimeSeriesDataSchema,
-} from './types.ts';
-import {
-	buildQueueHeaders,
-	QueueError,
-	QueueNotFoundError,
-	queueApiPathWithQuery,
-	withQueueErrorHandling,
-} from './util.ts';
-import { validateQueueName } from './validation.ts';
-
-export const OrgAnalyticsResponseSchema = APIResponseSchema(
-	z.object({ analytics: OrgAnalyticsSchema })
-);
-export const QueueAnalyticsResponseSchema = APIResponseSchema(
-	z.object({ analytics: QueueAnalyticsSchema })
-);
-export const TimeSeriesResponseSchema = APIResponseSchema(
-	z.object({ timeseries: TimeSeriesDataSchema })
-);
-
-/**
- * Build query string from analytics options.
- */
-function buildAnalyticsQuery(options?: AnalyticsOptions): string | undefined {
-	if (!options) return undefined;
-
-	const params = new URLSearchParams();
-	if (options.start) params.set('start', options.start);
-	if (options.end) params.set('end', options.end);
-	if (options.granularity) params.set('granularity', options.granularity);
-	if (options.projectId) params.set('project_id', options.projectId);
-	if (options.agentId) params.set('agent_id', options.agentId);
-
-	const query = params.toString();
-	return query || undefined;
-}
-
-/**
- * Get org-level analytics for all queues.
- *
- * Returns aggregated statistics across all queues in the organization.
- *
- * @param client - The API client instance
- * @param options - Analytics options (time range, filters)
- * @returns Org-level analytics summary
- * @throws {QueueError} If the API request fails
- *
- * @example
- * ```typescript
- * const analytics = await getOrgAnalytics(client, {
- *   start: '2026-01-14T00:00:00Z',
- *   end: '2026-01-15T00:00:00Z',
- * });
- * console.log(`Total queues: ${analytics.summary.total_queues}`);
- * console.log(`Messages published: ${analytics.summary.total_messages_published}`);
- * ```
- */
-export async function getOrgAnalytics(
-	client: APIClient,
-	options?: AnalyticsOptions
-): Promise<OrgAnalytics> {
-	const queryString = buildAnalyticsQuery(options);
-	const url = queueApiPathWithQuery('analytics/org', queryString);
-	const resp = await client.get(
-		url,
-		OrgAnalyticsResponseSchema,
-		undefined,
-		buildQueueHeaders(options?.orgId)
-	);
-
-	if (resp.success) {
-		return resp.data.analytics;
-	}
-
-	throw new QueueError({
-		message: resp.message || 'Failed to get org analytics',
-	});
-}
-
-/**
- * Get detailed analytics for a specific queue.
- *
- * Returns current state, period statistics, latency metrics, and destination stats.
- *
- * @param client - The API client instance
- * @param name - The queue name
- * @param options - Analytics options (time range, filters)
- * @returns Queue analytics
- * @throws {QueueNotFoundError} If the queue does not exist
- * @throws {QueueError} If the API request fails
- *
- * @example
- * ```typescript
- * const analytics = await getQueueAnalytics(client, 'order-processing', {
- *   start: '2026-01-14T00:00:00Z',
- * });
- * console.log(`Backlog: ${analytics.current.backlog}`);
- * console.log(`P95 latency: ${analytics.latency.p95_ms}ms`);
- * ```
- */
-export async function getQueueAnalytics(
-	client: APIClient,
-	name: string,
-	options?: AnalyticsOptions
-): Promise<QueueAnalytics> {
-	validateQueueName(name);
-	const queryString = buildAnalyticsQuery(options);
-	const url = queueApiPathWithQuery('analytics/queue', queryString, name);
-	const resp = await withQueueErrorHandling(
-		() =>
-			client.get(
-				url,
-				QueueAnalyticsResponseSchema,
-				undefined,
-				buildQueueHeaders(options?.orgId)
-			),
-		{ queueName: name }
-	);
-
-	if (resp.success) {
-		return resp.data.analytics;
-	}
-
-	throw new QueueError({
-		queueName: name,
-		message: resp.message || 'Failed to get queue analytics',
-	});
-}
-
-/**
- * Get time series analytics data for a queue.
- *
- * Returns time-bucketed metrics for visualization in charts and graphs.
- *
- * @param client - The API client instance
- * @param name - The queue name
- * @param options - Analytics options (time range, granularity)
- * @returns Time series data
- * @throws {QueueNotFoundError} If the queue does not exist
- * @throws {QueueError} If the API request fails
- *
- * @example
- * ```typescript
- * const timeseries = await getQueueTimeSeries(client, 'order-processing', {
- *   granularity: 'hour',
- *   start: '2026-01-14T00:00:00Z',
- * });
- * for (const point of timeseries.series) {
- *   console.log(`${point.timestamp}: ${point.throughput} msg/h`);
- * }
- * ```
- */
-export async function getQueueTimeSeries(
-	client: APIClient,
-	name: string,
-	options?: AnalyticsOptions
-): Promise<TimeSeriesData> {
-	validateQueueName(name);
-	const queryString = buildAnalyticsQuery(options);
-	const url = queueApiPathWithQuery('analytics/timeseries', queryString, name);
-	const resp = await withQueueErrorHandling(
-		() => client.get(url, TimeSeriesResponseSchema, undefined, buildQueueHeaders(options?.orgId)),
-		{ queueName: name }
-	);
-
-	if (resp.success) {
-		return resp.data.timeseries;
-	}
-
-	throw new QueueError({
-		queueName: name,
-		message: resp.message || 'Failed to get queue time series',
-	});
-}
-
-/**
- * Stream real-time analytics for all queues via SSE.
- *
- * Returns an async iterator that yields stats events at the specified interval.
- * The connection stays open until the iterator is closed or an error occurs.
- *
- * @param client - The API client instance
- * @param options - Stream options (interval, orgId)
- * @returns Async iterator of SSE stats events
- *
- * @example
- * ```typescript
- * const stream = streamOrgAnalytics(client, { interval: 5 });
- * for await (const event of stream) {
- *   console.log(`Backlog: ${event.backlog}, Throughput: ${event.throughput_1m}/min`);
- * }
- * ```
- */
-export async function* streamOrgAnalytics(
-	client: APIClient,
-	options?: StreamAnalyticsOptions
-): AsyncGenerator<SSEStatsEvent, void, unknown> {
-	const params = new URLSearchParams();
-	if (options?.interval) params.set('interval', String(options.interval));
-	const queryString = params.toString() || undefined;
-
-	const url = queueApiPathWithQuery('analytics/stream', queryString);
-
-	yield* streamSSE(client, url, options?.orgId);
-}
-
-/**
- * Stream real-time analytics for a specific queue via SSE.
- *
- * Returns an async iterator that yields stats events at the specified interval.
- *
- * @param client - The API client instance
- * @param name - The queue name
- * @param options - Stream options (interval, orgId)
- * @returns Async iterator of SSE stats events
- *
- * @example
- * ```typescript
- * const stream = streamQueueAnalytics(client, 'order-processing', { interval: 5 });
- * for await (const event of stream) {
- *   console.log(`Backlog: ${event.backlog}, In-flight: ${event.messages_in_flight}`);
- * }
- * ```
- */
-export async function* streamQueueAnalytics(
-	client: APIClient,
-	name: string,
-	options?: StreamAnalyticsOptions
-): AsyncGenerator<SSEStatsEvent, void, unknown> {
-	validateQueueName(name);
-
-	const params = new URLSearchParams();
-	if (options?.interval) params.set('interval', String(options.interval));
-	const queryString = params.toString() || undefined;
-
-	const url = queueApiPathWithQuery('analytics/stream', queryString, name);
-
-	yield* streamSSE(client, url, options?.orgId, name);
-}
-
-/**
- * Internal helper to stream SSE events from a URL.
- * Uses rawGet for streaming response access.
- */
-async function* streamSSE(
-	client: APIClient,
-	url: string,
-	orgId?: string,
-	queueName?: string
-): AsyncGenerator<SSEStatsEvent, void, unknown> {
-	const response = await client.rawGet(url, undefined, buildQueueHeaders(orgId));
-
-	if (!response.ok) {
-		if (response.status === 404 && queueName) {
-			throw new QueueNotFoundError({ queueName });
-		}
-		throw new QueueError({
-			message: `SSE connection failed: ${response.status} ${response.statusText}`,
-		});
-	}
-
-	const reader = response.body?.getReader();
-	if (!reader) {
-		throw new QueueError({ message: 'No response body for SSE stream' });
-	}
-
-	const decoder = new TextDecoder();
-	let buffer = '';
-
-	try {
-		while (true) {
-			const { done, value } = await reader.read();
-			if (done) break;
-
-			buffer += decoder.decode(value, { stream: true });
-			const lines = buffer.split('\n');
-			buffer = lines.pop() || '';
-
-			for (const line of lines) {
-				if (line.startsWith('data: ')) {
-					const jsonStr = line.slice(6).trim();
-					if (jsonStr && jsonStr !== '{}') {
-						try {
-							const parsed = JSON.parse(jsonStr);
-							const event = SSEStatsEventSchema.parse(parsed);
-							yield event;
-						} catch {
-							// Skip malformed events
-						}
-					}
-				}
-			}
-		}
-	} finally {
-		await reader.cancel();
-		reader.releaseLock();
-	}
-}