@agentuity/core 1.0.31 → 1.0.33

package/src/api/project/deployment.ts

@@ -0,0 +1,195 @@
+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/env-delete.ts

@@ -0,0 +1,45 @@
+import { z } from 'zod';
+import { type APIClient, APIResponseSchemaNoData } from '../api.ts';
+import { ProjectResponseError } from './util.ts';
+
+export const ProjectEnvDeleteRequestSchema = z
+	.object({
+		id: z.string().describe('the project id'),
+		env: z.array(z.string()).optional().describe('environment variable keys to delete'),
+		secrets: z.array(z.string()).optional().describe('secret keys to delete'),
+	})
+	.refine((data) => (data.env?.length ?? 0) > 0 || (data.secrets?.length ?? 0) > 0, {
+		message: 'must provide at least one of env or secrets',
+	});
+
+export const ProjectEnvDeleteResponseSchema = APIResponseSchemaNoData();
+
+type ProjectEnvDeleteRequest = z.infer<typeof ProjectEnvDeleteRequestSchema>;
+type ProjectEnvDeleteResponse = z.infer<typeof ProjectEnvDeleteResponseSchema>;
+
+/**
+ * Delete environment variables and/or secrets from a project.
+ * Provide arrays of keys to delete.
+ */
+export async function projectEnvDelete(
+	client: APIClient,
+	request: ProjectEnvDeleteRequest
+): Promise<void> {
+	const { id, env, secrets } = request;
+
+	const resp = await client.request<ProjectEnvDeleteResponse, Omit<ProjectEnvDeleteRequest, 'id'>>(
+		'DELETE',
+		`/cli/project/${id}/env`,
+		ProjectEnvDeleteResponseSchema,
+		{
+			env,
+			secrets,
+		}
+	);
+
+	if (!resp.success) {
+		throw new ProjectResponseError({ message: resp.message ?? 'failed to delete project env' });
+	}
+
+	// Delete operations don't return data, success is sufficient
+}

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

@@ -0,0 +1,55 @@
+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

@@ -0,0 +1,58 @@
+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/get.ts

@@ -0,0 +1,49 @@
+import { z } from 'zod';
+import { type APIClient, APIResponseSchema } from '../api.ts';
+import { ProjectResponseError } from './util.ts';
+
+export const ProjectGetRequestSchema = z.object({
+	id: z.string().describe('the project id'),
+	mask: z.boolean().default(true).optional().describe('if the secrets should be returned masked'),
+	keys: z.boolean().default(true).optional().describe('if the project keys should be returned'),
+});
+
+export const ProjectSchema = z.object({
+	id: z.string().describe('the project id'),
+	name: z.string().describe('the project name'),
+	description: z.string().nullable().optional().describe('the project description'),
+	tags: z.array(z.string()).nullable().optional().describe('the project tags'),
+	orgId: z.string().describe('the organization id'),
+	cloudRegion: z.string().nullable().optional().describe('the cloud region'),
+	vanityHostname: z.string().nullable().optional().describe('the vanity hostname'),
+	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'),
+});
+
+export const ProjectGetResponseSchema = APIResponseSchema(ProjectSchema);
+
+type ProjectGetRequest = z.infer<typeof ProjectGetRequestSchema>;
+type ProjectGetResponse = z.infer<typeof ProjectGetResponseSchema>;
+
+export type Project = z.infer<typeof ProjectSchema>;
+
+export async function projectGet(client: APIClient, request: ProjectGetRequest): Promise<Project> {
+	const keys = request.keys ?? true;
+	const resp = await client.get<ProjectGetResponse>(
+		`/cli/project/${request.id}?mask=${request.mask ?? true}&includeProjectKeys=${keys}`,
+		ProjectGetResponseSchema
+	);
+
+	if (resp.success) {
+		if (keys && resp.data.secrets?.AGENTUITY_SDK_KEY) {
+			return {
+				...resp.data,
+				api_key: resp.data.secrets.AGENTUITY_SDK_KEY,
+			};
+		}
+		return resp.data;
+	}
+
+	throw new ProjectResponseError({ message: resp.message });
+}

package/src/api/project/hostname.ts

@@ -0,0 +1,73 @@
+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

@@ -0,0 +1,13 @@
+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/list.ts

@@ -0,0 +1,54 @@
+import { z } from 'zod';
+import { type APIClient, APIResponseSchema } from '../api.ts';
+import { ProjectResponseError } from './util.ts';
+
+export const ProjectListItemSchema = z.object({
+	id: z.string().describe('the project id'),
+	name: z.string().describe('the project name'),
+	description: z.string().nullable().optional().describe('the project description'),
+	orgId: z.string().describe('the organization id that this project is registered with'),
+	orgName: z.string().describe('the organization name'),
+	cloudRegion: z.string().nullable().optional().describe('the cloud region'),
+	latestDeploymentId: z.string().nullable().describe('the latest deployment id'),
+});
+
+export const ProjectListSchema = z.array(ProjectListItemSchema);
+
+export const ProjectListResponseSchema = APIResponseSchema(ProjectListSchema);
+
+export type ProjectListResponse = z.infer<typeof ProjectListResponseSchema>;
+export type ProjectList = z.infer<typeof ProjectListSchema>;
+
+/**
+ * List all projects
+ *
+ * @param client
+ * @param hasDeployment if true, filter by projects with at least one deployment
+ * @param limit maximum number of projects to return (default: 1000, max: 10000)
+ * @returns
+ */
+export async function projectList(
+	client: APIClient,
+	hasDeployment?: boolean,
+	limit?: number
+): Promise<ProjectList> {
+	const params = new URLSearchParams();
+	if (hasDeployment) {
+		params.append('hasDeployment', 'true');
+	}
+	if (limit !== undefined) {
+		params.append('limit', limit.toString());
+	}
+	const queryString = params.toString();
+	const resp = await client.request<ProjectListResponse>(
+		'GET',
+		`/cli/project${queryString ? `?${queryString}` : ''}`,
+		ProjectListResponseSchema
+	);
+
+	if (resp.success) {
+		return resp.data;
+	}
+
+	throw new ProjectResponseError({ message: resp.message });
+}

package/src/api/project/malware.ts

@@ -0,0 +1,68 @@
+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/project/update-region.ts

@@ -0,0 +1,44 @@
+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

@@ -0,0 +1,8 @@
+import { StructuredError } from '../../error.ts';
+
+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;
+}>();