@agentuity/core 1.0.32 → 1.0.34

package/src/services/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/services/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/services/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/services/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/services/project/hostname.ts

@@ -0,0 +1,79 @@
+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()
+		.describe('The vanity hostname for the project, or null if not set.'),
+	url: z
+		.string()
+		.nullable()
+		.describe('The full URL for the project hostname, or null if not set.'),
+});
+
+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().describe('The vanity hostname that was set.'),
+	url: z.string().describe('The full URL for the project hostname.'),
+});
+
+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/services/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/services/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/services/project/malware.ts

@@ -0,0 +1,85 @@
+import { z } from 'zod';
+import { type APIClient, APIResponseSchema } from '../api.ts';
+import { MalwareCheckError } from './util.ts';
+
+export const PackageRefSchema = z
+	.object({
+		name: z.string().describe('Package name (e.g., lodash, express).'),
+		version: z.string().describe('Package version (e.g., 4.17.21).'),
+	})
+	.describe('Reference to an npm package with name and version.');
+
+export type PackageRef = z.infer<typeof PackageRefSchema>;
+
+export const MalwareFindingSchema = z
+	.object({
+		name: z.string().describe('Name of the flagged package.'),
+		version: z.string().describe('Version of the flagged package.'),
+		reason: z.string().describe('Reason why the package was flagged as potentially malicious.'),
+	})
+	.describe('A malware detection finding for a specific package.');
+
+export type MalwareFinding = z.infer<typeof MalwareFindingSchema>;
+
+export const MalwareCheckSummarySchema = z
+	.object({
+		scanned: z.number().describe('Total number of packages scanned.'),
+		flagged: z.number().describe('Number of packages flagged as potentially malicious.'),
+	})
+	.describe('Summary of a malware check scan.');
+
+export const MalwareCheckListMetadataSchema = z
+	.object({
+		fetchedAt: z.string().describe('ISO 8601 timestamp when the malware list was last fetched.'),
+		count: z.number().describe('Number of entries in the malware list.'),
+	})
+	.describe('Metadata about the malware detection list used for scanning.');
+
+export const MalwareCheckResultSchema = z
+	.object({
+		action: z
+			.enum(['allow', 'block'])
+			.describe('Action to take based on the scan results (allow or block deployment).'),
+		summary: MalwareCheckSummarySchema.describe('Summary of the malware check scan.'),
+		findings: z.array(MalwareFindingSchema).describe('List of malware detection findings.'),
+		list: MalwareCheckListMetadataSchema.optional().describe(
+			'Metadata about the malware list used, if available.'
+		),
+		error: z
+			.string()
+			.optional()
+			.describe('Error message if the malware check encountered an issue.'),
+	})
+	.describe('Result of a malware check for a deployment.');
+
+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/services/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/services/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;
+}>();