@agentuity/server 0.0.42 → 0.0.44

package/src/api/project/deploy.ts

@@ -0,0 +1,224 @@
+import { z } from 'zod';
+import { type APIClient, APIResponseSchema } from '../api';
+
+export const Resources = z.object({
+	memory: z.string().default('500Mi').describe('The memory requirements'),
+	cpu: z.string().default('500m').describe('The CPU requirements'),
+	disk: z.string().default('500Mi').describe('The disk requirements'),
+	db: z.string().optional().describe('the name of the database to use'),
+	storage: z.string().optional().describe('the name of the storage bucket to use'),
+});
+
+export const Mode = z.object({
+	type: z
+		.enum(['on-demand', 'provisioned'])
+		.default('on-demand')
+		.describe('on-demand or provisioned'),
+	idle: z.string().optional().describe('duration in seconds if on-demand'),
+});
+
+export const Deployment = z.object({
+	resources: Resources.optional().describe('the resource requirements for your deployed project'),
+	mode: Mode.optional().describe('the provisioning mode for the project'),
+	dependencies: z
+		.array(z.string().describe('APT dependencies to install prior to launching your project'))
+		.optional(),
+	domains: z.array(z.string().describe('the custom domain')).optional(),
+});
+
+const BaseFileFields = {
+	filename: z.string().describe('the relative path for the file'),
+	version: z.string().describe('the SHA256 content of the file'),
+	identifier: z.string().describe('the folder for the file'),
+};
+
+const EvalSchema = z.object({
+	...BaseFileFields,
+	id: z.string().describe('the unique calculated id for the eval'),
+	name: z.string().describe('the name of the eval'),
+	description: z.string().optional().describe('the eval description'),
+});
+
+const BaseAgentFields = {
+	...BaseFileFields,
+	id: z.string().describe('the unique calculated id for the agent'),
+	name: z.string().describe('the name of the agent'),
+	description: z.string().optional().describe('the agent description'),
+	evals: z.array(EvalSchema).optional().describe('the evals for the agent'),
+};
+
+const AgentSchema = z.object({
+	...BaseAgentFields,
+	subagents: z.array(z.object(BaseAgentFields)).optional().describe('subagents of this agent'),
+});
+
+export const BuildMetadataSchema = z.object({
+	routes: z.array(
+		z.object({
+			id: z.string().describe('the unique calculated id for the route'),
+			filename: z.string().describe('the relative path for the file'),
+			path: z.string().describe('the route path'),
+			method: z.enum(['get', 'post', 'put', 'delete', 'patch']).describe('the HTTP method'),
+			version: z.string().describe('the SHA256 content of the file'),
+			type: z.enum(['api', 'sms', 'email', 'cron', 'websocket', 'sse', 'stream']),
+			config: z
+				.record(z.string(), z.unknown())
+				.optional()
+				.describe('type specific configuration'),
+		})
+	),
+	agents: z.array(AgentSchema),
+	assets: z.array(
+		z.object({
+			filename: z.string().describe('the relative path for the file'),
+			kind: z.string().describe('the type of asset'),
+			contentType: z.string().describe('the content-type for the file'),
+			size: z.number().describe('the size in bytes for the file'),
+		})
+	),
+	project: z.object({
+		id: z.string().describe('the project id'),
+		name: z.string().describe('the name of the project (from package.json)'),
+		version: z.string().optional().describe('the version of the project (from package.json)'),
+		orgId: z.string().describe('the organization id for the project'),
+	}),
+	deployment: z.intersection(
+		Deployment,
+		z.object({
+			id: z.string().describe('the deployment id'),
+			date: z.string().describe('the date the deployment was created in UTC format'),
+			git: z
+				.object({
+					repo: z.string().optional().describe('the repository name'),
+					commit: z.string().optional().describe('the git commit sha'),
+					message: z.string().optional().describe('the git commit message'),
+					branch: z.string().optional().describe('the git branch'),
+					tags: z.array(z.string()).optional().describe('the tags for the current branch'),
+					pr: z.string().optional().describe('the pull request number'),
+				})
+				.optional()
+				.describe('git commit information'),
+			build: z.object({
+				bun: z.string().describe('the version of bun that was used to build the deployment'),
+				agentuity: z.string().describe('the version of the agentuity runtime'),
+				arch: z.string().describe('the machine architecture'),
+				platform: z.string().describe('the machine os platform'),
+			}),
+		})
+	),
+});
+
+export type BuildMetadata = z.infer<typeof BuildMetadataSchema>;
+
+const CreateProjectDeployment = z.object({
+	id: z.string().describe('the unique id for the deployment'),
+	orgId: z.string().describe('the organization id'),
+	publicKey: z.string().describe('the public key to use for encrypting the deployment'),
+});
+
+const CreateProjectDeploymentSchema = APIResponseSchema(CreateProjectDeployment);
+
+type CreateProjectDeploymentPayload = z.infer<typeof CreateProjectDeploymentSchema>;
+
+export type Deployment = z.infer<typeof CreateProjectDeployment>;
+
+/**
+ * Create a new project deployment
+ *
+ * @param client
+ * @param projectId
+ * @returns
+ */
+export async function projectDeploymentCreate(
+	client: APIClient,
+	projectId: string,
+	deploymentConfig?: z.infer<typeof Deployment>
+): Promise<Deployment> {
+	const resp = await client.request<CreateProjectDeploymentPayload>(
+		'POST',
+		`/cli/deploy/1/start/${projectId}`,
+		CreateProjectDeploymentSchema,
+		deploymentConfig
+	);
+	if (resp.success) {
+		return resp.data;
+	}
+	throw new Error(resp.message);
+}
+
+const DeploymentInstructionsObject = z.object({
+	deployment: z.string().describe('the url for uploading the encrypted deployment archive'),
+	assets: z
+		.record(
+			z.string().describe('the asset id'),
+			z.string().describe('the url for the asset upload')
+		)
+		.describe('the upload metadata for public assets'),
+});
+
+const DeploymentInstructionsSchema = APIResponseSchema(DeploymentInstructionsObject);
+
+type DeploymentInstructionsResponse = z.infer<typeof DeploymentInstructionsSchema>;
+export type DeploymentInstructions = z.infer<typeof DeploymentInstructionsObject>;
+
+/**
+ * Update the deployment with the build metadata
+ *
+ * @param client
+ * @param deploymentId
+ * @returns
+ */
+export async function projectDeploymentUpdate(
+	client: APIClient,
+	deploymentId: string,
+	deployment: BuildMetadata
+): Promise<DeploymentInstructions> {
+	const resp = await client.request<DeploymentInstructionsResponse, BuildMetadata>(
+		'PUT',
+		`/cli/deploy/1/start/${deploymentId}`,
+		DeploymentInstructionsSchema,
+		deployment,
+		BuildMetadataSchema
+	);
+	if (resp.success) {
+		return resp.data;
+	}
+	throw new Error(resp.message);
+}
+
+const DeploymentCompleteObject = z.object({
+	publicUrls: z
+		.object({
+			latest: z.url().describe('the public url for the latest deployment'),
+			deployment: z.url().describe('the public url for this deployment'),
+			custom: z.array(z.string().describe('the custom domain')),
+		})
+		.describe('the map of public urls'),
+});
+
+const DeploymentCompleteObjectSchema = APIResponseSchema(DeploymentCompleteObject);
+
+type DeploymentCompleteResponse = z.infer<typeof DeploymentCompleteObjectSchema>;
+export type DeploymentComplete = z.infer<typeof DeploymentCompleteObject>;
+
+/**
+ * Complete the deployment once build is uploaded
+ *
+ * @param client
+ * @param deploymentId
+ * @returns
+ */
+export async function projectDeploymentComplete(
+	client: APIClient,
+	deploymentId: string
+): Promise<DeploymentComplete> {
+	const resp = await client.request<DeploymentCompleteResponse>(
+		'POST',
+		`/cli/deploy/1/complete/${deploymentId}`,
+		DeploymentCompleteObjectSchema
+	);
+	if (resp.success) {
+		return resp.data;
+	}
+	throw new Error(resp.message);
+}

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

@@ -0,0 +1,40 @@
+import { z } from 'zod';
+import { APIClient, APIResponseSchemaNoData } from '../api';
+
+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'),
+});
+
+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 Error(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,59 @@
+import { z } from 'zod';
+import { APIClient, APIResponseSchema } from '../api';
+import type { Project } from './get';
+import { projectGet } from './get';
+
+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'),
+});
+
+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 Error(resp.message ?? 'failed to update project env');
+	}
+
+	if (resp.data) {
+		return resp.data;
+	}
+
+	// If the API didn't return data, fetch the updated project
+	// This handles backends that return success without the full project data
+	return projectGet(client, { id, mask: false });
+}

package/src/api/project/exists.ts

@@ -35,7 +35,7 @@ export async function projectExists(
 			ProjectExistsResponseSchema
 		);
 
-		if (resp.data) {
+		if (resp.success) {
 			return resp.data;
 		}
 

package/src/api/project/get.ts

@@ -6,20 +6,20 @@ const _ProjectGetRequestSchema = z.object({
 	mask: z.boolean().default(true).describe('if the secrets should be returned masked'),
 });
 
-const ProjectGetResponseSchema = 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'),
-	})
-);
+const ProjectSchema = 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'),
+});
+
+const ProjectGetResponseSchema = APIResponseSchema(ProjectSchema);
 
 type ProjectGetRequest = z.infer<typeof _ProjectGetRequestSchema>;
 type ProjectGetResponse = z.infer<typeof ProjectGetResponseSchema>;
 
-export type Project = NonNullable<ProjectGetResponse['data']>;
+export type Project = z.infer<typeof ProjectSchema>;
 
 export async function projectGet(client: APIClient, request: ProjectGetRequest): Promise<Project> {
 	const resp = await client.request<ProjectGetResponse, ProjectGetRequest>(
@@ -28,9 +28,9 @@ export async function projectGet(client: APIClient, request: ProjectGetRequest):
 		ProjectGetResponseSchema
 	);
 
-	if (resp.data) {
+	if (resp.success) {
 		return resp.data;
 	}
 
-	throw new Error(resp.message ?? 'failed to get project');
+	throw new Error(resp.message);
 }

package/src/api/project/index.ts

@@ -1,5 +1,8 @@
 export * from './create';
 export * from './delete';
+export * from './deploy';
+export * from './env-delete';
+export * from './env-update';
 export * from './exists';
 export * from './get';
 export * from './list';

package/src/api/project/list.ts

@@ -1,37 +1,42 @@
 import { z } from 'zod';
 import { APIClient, APIResponseSchema } from '../api';
 
-const ProjectListResponseSchema = APIResponseSchema(
-	z.array(
-		z.object({
-			id: z.string().describe('the project id'),
-			name: z.string().describe('the project name'),
-			description: z.string().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'),
-		})
-	)
+const ProjectListResponse = z.array(
+	z.object({
+		id: z.string().describe('the project id'),
+		name: z.string().describe('the project name'),
+		description: z.string().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'),
+		latestDeploymentId: z.string().nullable().describe('the latest deployment id'),
+	})
 );
 
+const ProjectListResponseSchema = APIResponseSchema(ProjectListResponse);
+
 export type ProjectListResponse = z.infer<typeof ProjectListResponseSchema>;
-export type ProjectList = NonNullable<ProjectListResponse['data']>;
+export type ProjectList = z.infer<typeof ProjectListResponse>;
 
 /**
  * List all projects
  *
  * @param client
+ * @param hasDeployment if true, filter by projects with at least one deployment
  * @returns
  */
-export async function projectList(client: APIClient): Promise<ProjectList> {
+export async function projectList(
+	client: APIClient,
+	hasDeployment?: boolean
+): Promise<ProjectList> {
 	const resp = await client.request<ProjectListResponse>(
 		'GET',
-		'/cli/project',
+		`/cli/project${hasDeployment ? '?hasDeployment=true' : ''}`,
 		ProjectListResponseSchema
 	);
 
-	if (resp.data) {
+	if (resp.success) {
 		return resp.data;
 	}
 
-	throw new Error(resp.message ?? 'failed to list projects');
+	throw new Error(resp.message);
 }

package/src/api/region/create.ts

@@ -0,0 +1,55 @@
+import { z } from 'zod';
+import { APIResponseSchema, APIClient } from '../api';
+
+const ResourceSpec = z.object({
+	type: z.enum(['db', 's3']).describe('the resource type'),
+	name: z.string().optional().describe('optional custom name for db'),
+});
+
+const CreateResourcesRequest = z.object({
+	resources: z.array(ResourceSpec).describe('list of resources to create'),
+});
+
+const CreatedResource = z.object({
+	type: z.string().describe('the resource type'),
+	name: z.string().describe('the resource name'),
+});
+
+const CreateResourcesResponse = z.object({
+	created: z.array(CreatedResource),
+});
+
+const CreateResourcesResponseSchema = APIResponseSchema(CreateResourcesResponse);
+
+export type CreateResourcesRequest = z.infer<typeof CreateResourcesRequest>;
+export type CreateResourcesResponse = z.infer<typeof CreateResourcesResponseSchema>;
+export type CreatedResource = z.infer<typeof CreatedResource>;
+
+/**
+ * Create one or more resources (DB or S3) for an organization in a specific region
+ * Requires CLI authentication
+ *
+ * @param client - Catalyst API client
+ * @param orgId - Organization ID
+ * @param region - Cloud region
+ * @param resources - Array of resources to create
+ * @returns
+ */
+export async function createResources(
+	client: APIClient,
+	orgId: string,
+	region: string,
+	resources: Array<{ type: 'db' | 's3'; name?: string }>
+): Promise<CreatedResource[]> {
+	const resp = await client.request<CreateResourcesResponse, CreateResourcesRequest>(
+		'POST',
+		`/resource/2025-11-16/${orgId}/${region}`,
+		CreateResourcesResponseSchema,
+		{ resources },
+		CreateResourcesRequest
+	);
+	if (resp.success) {
+		return resp.data.created;
+	}
+	throw new Error('message' in resp ? resp.message : 'Failed to create resources');
+}

package/src/api/region/delete.ts

@@ -0,0 +1,49 @@
+import { z } from 'zod';
+import { APIResponseSchema, APIClient } from '../api';
+
+const DeleteResourceSpec = z.object({
+	type: z.enum(['db', 's3']).describe('the resource type'),
+	name: z.string().describe('the resource name (bucket_name for S3, db_name for DB)'),
+});
+
+const DeleteResourcesRequest = z.object({
+	resources: z.array(DeleteResourceSpec).describe('list of resources to delete'),
+});
+
+const DeleteResourcesResponse = z.object({
+	deleted: z.array(z.string()).describe('list of deleted resource names'),
+});
+
+const DeleteResourcesResponseSchema = APIResponseSchema(DeleteResourcesResponse);
+
+export type DeleteResourcesRequest = z.infer<typeof DeleteResourcesRequest>;
+export type DeleteResourcesResponse = z.infer<typeof DeleteResourcesResponseSchema>;
+
+/**
+ * Delete one or more resources (DB or S3) for an organization in a specific region
+ * Requires CLI authentication
+ *
+ * @param client - Catalyst API client
+ * @param orgId - Organization ID
+ * @param region - Cloud region
+ * @param resources - Array of resources to delete
+ * @returns
+ */
+export async function deleteResources(
+	client: APIClient,
+	orgId: string,
+	region: string,
+	resources: Array<{ type: 'db' | 's3'; name: string }>
+): Promise<string[]> {
+	const resp = await client.request<DeleteResourcesResponse, DeleteResourcesRequest>(
+		'DELETE',
+		`/resource/2025-11-16/${orgId}/${region}`,
+		DeleteResourcesResponseSchema,
+		{ resources },
+		DeleteResourcesRequest
+	);
+	if (resp.success) {
+		return resp.data.deleted;
+	}
+	throw new Error('message' in resp ? resp.message : 'Failed to delete resources');
+}

package/src/api/region/index.ts

@@ -0,0 +1,4 @@
+export * from './list';
+export * from './resources';
+export * from './create';
+export * from './delete';

package/src/api/region/list.ts

@@ -0,0 +1,31 @@
+import { z } from 'zod';
+import { APIResponseSchema, APIClient } from '../api';
+
+const ListRegionsResponse = z.array(
+	z.object({
+		region: z.string().describe('the region identifier'),
+		description: z.string().describe('the human-readable description of the region'),
+	})
+);
+const ListRegionsResponseSchema = APIResponseSchema(ListRegionsResponse);
+
+export type ListRegionsResponse = z.infer<typeof ListRegionsResponseSchema>;
+export type RegionList = z.infer<typeof ListRegionsResponse>;
+
+/**
+ * List all available cloud regions
+ *
+ * @param client
+ * @returns
+ */
+export async function listRegions(client: APIClient): Promise<RegionList> {
+	const resp = await client.request<ListRegionsResponse>(
+		'GET',
+		'/cli/region',
+		ListRegionsResponseSchema
+	);
+	if (resp.success) {
+		return resp.data;
+	}
+	throw new Error(resp.message);
+}

package/src/api/region/resources.ts

@@ -0,0 +1,51 @@
+import { z } from 'zod';
+import { APIResponseSchema, APIClient } from '../api';
+
+const ResourceListResponse = z.object({
+	s3: z.array(
+		z.object({
+			bucket_name: z.string().describe('the S3 bucket name'),
+			access_key: z.string().nullable().optional().describe('the S3 access key'),
+			secret_key: z.string().nullable().optional().describe('the S3 secret key'),
+			region: z.string().nullable().optional().describe('the S3 region'),
+			endpoint: z.string().nullable().optional().describe('the S3 endpoint'),
+			cname: z.string().nullable().optional().describe('the S3 CNAME'),
+		})
+	),
+	db: z.array(
+		z.object({
+			name: z.string().describe('the database name'),
+			username: z.string().nullable().optional().describe('the database username'),
+			password: z.string().nullable().optional().describe('the database password'),
+			url: z.string().nullable().optional().describe('the full database connection URL'),
+		})
+	),
+});
+const ResourceListResponseSchema = APIResponseSchema(ResourceListResponse);
+
+export type ResourceListResponse = z.infer<typeof ResourceListResponseSchema>;
+export type ResourceList = z.infer<typeof ResourceListResponse>;
+
+/**
+ * List all resources for a given organization and region
+ *
+ * @param client
+ * @param orgId
+ * @param region
+ * @returns
+ */
+export async function listResources(
+	client: APIClient,
+	orgId: string,
+	region: string
+): Promise<ResourceList> {
+	const resp = await client.request<ResourceListResponse>(
+		'GET',
+		`/resource/2025-03-17/${orgId}/${region}`,
+		ResourceListResponseSchema
+	);
+	if (resp.success) {
+		return resp.data;
+	}
+	throw new Error(resp.message);
+}

package/src/api/user/index.ts

@@ -0,0 +1 @@
+export * from './whoami';

package/src/api/user/whoami.ts

@@ -0,0 +1,31 @@
+import { z } from 'zod';
+import { APIResponseSchema, APIClient } from '../api';
+
+const OrganizationSchema = z.object({
+	id: z.string().describe('the unique id for the organization'),
+	name: z.string().describe('the name of the organization'),
+});
+
+const WhoamiResponse = z.object({
+	firstName: z.string().describe('the first name of the user'),
+	lastName: z.string().describe('the last name of the user'),
+	organizations: z.array(OrganizationSchema).describe('the organizations the user is a member of'),
+});
+const WhoamiResponseSchema = APIResponseSchema(WhoamiResponse);
+
+export type WhoamiResponse = z.infer<typeof WhoamiResponseSchema>;
+export type User = z.infer<typeof WhoamiResponse>;
+
+/**
+ * Get the current authenticated user information
+ *
+ * @param client
+ * @returns
+ */
+export async function whoami(client: APIClient): Promise<User> {
+	const resp = await client.request<WhoamiResponse>('GET', '/cli/auth/user', WhoamiResponseSchema);
+	if (resp.success) {
+		return resp.data;
+	}
+	throw new Error(resp.message);
+}