@agentuity/core 1.0.33 → 1.0.35

package/src/api/project/deployment.ts

@@ -1,195 +0,0 @@
-import { z } from 'zod';
-import { type APIClient, APIResponseSchema, APIResponseSchemaOptionalData } from '../api.ts';
-import { ProjectResponseError } from './util.ts';
-
-// Simplified metadata schema for the client
-export const DeploymentMetadataSchema = z.object({
-	git: z
-		.object({
-			repo: z.string().optional(),
-			commit: z.string().optional(),
-			message: z.string().optional(),
-			branch: z.string().optional(),
-			tags: z.array(z.string()).optional(),
-			pr: z.string().optional(),
-			provider: z.string().optional(),
-			trigger: z.string().optional(),
-			url: z.string().optional(),
-			buildUrl: z.string().optional(),
-			event: z.string().optional(),
-			pull_request: z
-				.object({
-					number: z.number(),
-					url: z.string().optional(),
-				})
-				.optional(),
-		})
-		.optional(),
-	build: z
-		.object({
-			bun: z.string().optional(),
-			agentuity: z.string().optional(),
-			arch: z.string().optional(),
-			platform: z.string().optional(),
-		})
-		.optional(),
-});
-
-export const DeploymentSchema = z.object({
-	id: z.string(),
-	state: z.string().optional(),
-	message: z.string().nullable().optional(),
-	tags: z.array(z.string()),
-	active: z.boolean(),
-	createdAt: z.string(),
-	updatedAt: z.string().nullable().optional(),
-	metadata: DeploymentMetadataSchema.optional(),
-	customDomains: z.array(z.string()).nullable().optional(),
-	cloudRegion: z.string().nullable().optional(),
-	resourceDb: z.string().nullable().optional(),
-	resourceStorage: z.string().nullable().optional(),
-	deploymentLogsURL: z.string().nullable().optional(),
-	buildLogsURL: z.string().nullable().optional(),
-	dnsRecords: z.array(z.string()).optional(),
-});
-
-export const DeploymentListResponseSchema = APIResponseSchema(z.array(DeploymentSchema));
-export const DeploymentGetResponseSchema = APIResponseSchema(DeploymentSchema);
-export const DeploymentActionResponseSchema = APIResponseSchemaOptionalData(
-	z.object({ activeDeploymentId: z.string().optional() })
-);
-
-export type DeploymentInfo = z.infer<typeof DeploymentSchema>;
-
-export async function projectDeploymentList(
-	client: APIClient,
-	projectId: string,
-	limit = 10,
-	options?: { orgId?: string }
-): Promise<DeploymentInfo[]> {
-	const params = new URLSearchParams({ limit: String(limit) });
-	if (options?.orgId) params.set('orgId', options.orgId);
-	const resp = await client.get(
-		`/cli/project/${projectId}/deployments?${params.toString()}`,
-		DeploymentListResponseSchema
-	);
-	if (resp.success) {
-		return resp.data;
-	}
-	throw new ProjectResponseError({ message: resp.message });
-}
-
-export async function projectDeploymentGet(
-	client: APIClient,
-	projectId: string,
-	deploymentId: string
-): Promise<DeploymentInfo> {
-	const resp = await client.get(
-		`/cli/project/${projectId}/deployments/${deploymentId}`,
-		DeploymentGetResponseSchema
-	);
-	if (resp.success) {
-		return resp.data;
-	}
-	throw new ProjectResponseError({ message: resp.message });
-}
-
-export const DeploymentLookupSchema = z.object({
-	id: z.string(),
-	projectId: z.string(),
-	orgId: z.string(),
-	cloudRegion: z.string().nullable().optional(),
-	state: z.string().nullable().optional(),
-	active: z.boolean(),
-});
-
-export const DeploymentLookupResponseSchema = APIResponseSchema(DeploymentLookupSchema);
-
-export type DeploymentLookup = z.infer<typeof DeploymentLookupSchema>;
-
-/**
- * Get deployment info by ID only (without requiring project ID).
- * Useful for looking up region/project info for a deployment.
- */
-export async function deploymentGet(
-	client: APIClient,
-	deploymentId: string
-): Promise<DeploymentLookup> {
-	const resp = await client.get(`/cli/deployment/${deploymentId}`, DeploymentLookupResponseSchema);
-	if (resp.success) {
-		return resp.data;
-	}
-	throw new ProjectResponseError({ message: resp.message });
-}
-
-export async function projectDeploymentDelete(
-	client: APIClient,
-	projectId: string,
-	deploymentId: string
-): Promise<void> {
-	const resp = await client.delete(
-		`/cli/project/${projectId}/deployments/${deploymentId}`,
-		DeploymentActionResponseSchema
-	);
-	if (!resp.success) {
-		throw new ProjectResponseError({ message: resp.message });
-	}
-}
-
-export async function projectDeploymentRollback(
-	client: APIClient,
-	projectId: string,
-	deploymentId: string
-): Promise<void> {
-	const resp = await client.post(
-		`/cli/project/${projectId}/deployments/${deploymentId}/rollback`,
-		undefined,
-		DeploymentActionResponseSchema
-	);
-	if (!resp.success) {
-		throw new ProjectResponseError({ message: resp.message });
-	}
-}
-
-export async function projectDeploymentUndeploy(
-	client: APIClient,
-	projectId: string
-): Promise<void> {
-	const resp = await client.post(
-		`/cli/project/${projectId}/deployments/undeploy`,
-		undefined,
-		DeploymentActionResponseSchema
-	);
-	if (!resp.success) {
-		throw new ProjectResponseError({ message: resp.message });
-	}
-}
-
-export const DeploymentLogSchema = z.object({
-	body: z.string(),
-	severity: z.string(),
-	timestamp: z.string(),
-	spanId: z.string(),
-	traceId: z.string(),
-	serviceName: z.string(),
-});
-
-export const DeploymentLogsResponseSchema = APIResponseSchema(z.array(DeploymentLogSchema));
-
-export type DeploymentLog = z.infer<typeof DeploymentLogSchema>;
-
-export async function projectDeploymentLogs(
-	client: APIClient,
-	projectId: string,
-	deploymentId: string,
-	limit = 100
-): Promise<DeploymentLog[]> {
-	const resp = await client.get(
-		`/cli/project/${projectId}/deployments/${deploymentId}/logs?limit=${limit}`,
-		DeploymentLogsResponseSchema
-	);
-	if (resp.success) {
-		return resp.data;
-	}
-	throw new ProjectResponseError({ message: resp.message });
-}

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/malware.ts

@@ -1,68 +0,0 @@
-import { z } from 'zod';
-import { type APIClient, APIResponseSchema } from '../api.ts';
-import { MalwareCheckError } from './util.ts';
-
-export const PackageRefSchema = z.object({
-	name: z.string(),
-	version: z.string(),
-});
-
-export type PackageRef = z.infer<typeof PackageRefSchema>;
-
-export const MalwareFindingSchema = z.object({
-	name: z.string(),
-	version: z.string(),
-	reason: z.string(),
-});
-
-export type MalwareFinding = z.infer<typeof MalwareFindingSchema>;
-
-export const MalwareCheckSummarySchema = z.object({
-	scanned: z.number(),
-	flagged: z.number(),
-});
-
-export const MalwareCheckListMetadataSchema = z.object({
-	fetchedAt: z.string(),
-	count: z.number(),
-});
-
-export const MalwareCheckResultSchema = z.object({
-	action: z.enum(['allow', 'block']),
-	summary: MalwareCheckSummarySchema,
-	findings: z.array(MalwareFindingSchema),
-	list: MalwareCheckListMetadataSchema.optional(),
-	error: z.string().optional(),
-});
-
-export const MalwareCheckResponseSchema = APIResponseSchema(MalwareCheckResultSchema);
-
-export type MalwareCheckResult = z.infer<typeof MalwareCheckResultSchema>;
-
-export async function projectDeploymentMalwareCheck(
-	client: APIClient,
-	deploymentId: string,
-	packages: PackageRef[],
-	signal?: AbortSignal
-): Promise<MalwareCheckResult> {
-	const resp = await client.request<z.infer<typeof MalwareCheckResponseSchema>>(
-		'POST',
-		`/security/${encodeURIComponent(deploymentId)}/malware-check`,
-		MalwareCheckResponseSchema,
-		{
-			ecosystem: 'npm',
-			packages,
-		},
-		undefined,
-		signal
-	);
-
-	if (!resp.success) {
-		throw new MalwareCheckError({
-			message: resp.message || 'Malware check request failed',
-			deploymentId,
-		});
-	}
-
-	return resp.data;
-}

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();
-	}
-}