@agentuity/server 1.0.31 → 1.0.33

package/src/api/sandbox/cli-list.ts

@@ -1,127 +0,0 @@
-import { z } from 'zod';
-import { type APIClient, APIResponseSchema } from '../api.ts';
-import { SandboxResponseError } from './util.ts';
-
-export const SandboxInfoSchema = z.object({
-	id: z.string().describe('the sandbox id'),
-	name: z.string().nullable().describe('the sandbox name'),
-	description: z.string().nullable().describe('the sandbox description'),
-	status: z.string().describe('sandbox status'),
-	region: z.string().nullable().describe('cloud region'),
-	createdAt: z.string().nullable().describe('ISO 8601 creation timestamp'),
-	orgId: z.string().describe('the organization id'),
-	orgName: z.string().nullable().describe('the organization name'),
-	projectId: z.string().nullable().describe('the project id'),
-});
-
-export const SandboxListDataSchema = z.object({
-	sandboxes: z.array(SandboxInfoSchema).describe('list of sandboxes'),
-	total: z.number().describe('total count of matching sandboxes'),
-});
-
-export const SandboxListResponseSchema = APIResponseSchema(SandboxListDataSchema);
-
-export type CLISandboxListResponse = z.infer<typeof SandboxListResponseSchema>;
-export type CLISandboxListData = z.infer<typeof SandboxListDataSchema>;
-export type CLISandboxInfo = z.infer<typeof SandboxInfoSchema>;
-
-export interface CLISandboxListOptions {
-	/**
-	 * Filter by sandbox name
-	 */
-	name?: string;
-	/**
-	 * Filter by sandbox mode
-	 */
-	mode?: 'oneshot' | 'interactive';
-	/**
-	 * Filter by specific project ID
-	 */
-	projectId?: string;
-	/**
-	 * Filter by specific organization ID
-	 */
-	orgId?: string;
-	/**
-	 * Filter by sandbox status
-	 */
-	status?:
-		| 'creating'
-		| 'idle'
-		| 'running'
-		| 'paused'
-		| 'stopping'
-		| 'suspended'
-		| 'terminated'
-		| 'failed';
-	/**
-	 * Maximum number of sandboxes to return (default: 50, max: 100)
-	 */
-	limit?: number;
-	/**
-	 * Number of sandboxes to skip for pagination
-	 */
-	offset?: number;
-	/**
-	 * Field to sort by
-	 */
-	sort?: string;
-	/**
-	 * Sort direction (default: 'desc')
-	 */
-	direction?: 'asc' | 'desc';
-}
-
-/**
- * List sandboxes with optional filtering using the CLI API endpoint.
- *
- * This endpoint searches across all organizations the user is a member of,
- * unlike the Catalyst API which requires an orgId.
- *
- * @param client - The API client
- * @param options - Filtering and pagination options
- * @returns A promise that resolves to the list of sandboxes
- *
- * @example
- * // List all sandboxes across all orgs
- * const result = await cliSandboxList(client);
- * console.log(`Found ${result.total} sandboxes`);
- *
- * @example
- * // List running sandboxes
- * const result = await cliSandboxList(client, { status: 'running' });
- *
- * @example
- * // List sandboxes for a specific project
- * const result = await cliSandboxList(client, { projectId: 'proj_123' });
- */
-export async function cliSandboxList(
-	client: APIClient,
-	options: CLISandboxListOptions = {}
-): Promise<CLISandboxListData> {
-	const { projectId, orgId, status, limit, offset, sort, direction } = options;
-	const params = new URLSearchParams();
-
-	if (options.name) params.set('name', options.name);
-	if (options.mode) params.set('mode', options.mode);
-	if (projectId) params.set('projectId', projectId);
-	if (orgId) params.set('orgId', orgId);
-	if (status) params.set('status', status);
-	if (limit !== undefined) params.set('limit', limit.toString());
-	if (offset !== undefined) params.set('offset', offset.toString());
-	if (sort) params.set('sort', sort);
-	if (direction) params.set('direction', direction);
-
-	const queryString = params.toString();
-	const resp = await client.request<CLISandboxListResponse>(
-		'GET',
-		`/cli/sandbox${queryString ? `?${queryString}` : ''}`,
-		SandboxListResponseSchema
-	);
-
-	if (resp.success) {
-		return resp.data;
-	}
-
-	throw new SandboxResponseError({ message: resp.message });
-}

package/src/api/sandbox/create.ts

@@ -1,256 +0,0 @@
-import type { SandboxCreateOptions, SandboxStatus } from '@agentuity/core';
-import { z } from 'zod';
-import { type APIClient, APIResponseSchema } from '../api.ts';
-import { NPM_PACKAGE_NAME_PATTERN } from './snapshot-build.ts';
-import { API_VERSION, throwSandboxError } from './util.ts';
-
-export const SandboxCreateRequestSchema = z
-	.object({
-		projectId: z.string().optional().describe('Project ID to associate the sandbox with'),
-		runtime: z.string().optional().describe('Runtime name (e.g., "bun:1", "python:3.14")'),
-		runtimeId: z.string().optional().describe('Runtime ID (e.g., "srt_xxx")'),
-		name: z.string().optional().describe('Optional sandbox name'),
-		description: z.string().optional().describe('Optional sandbox description'),
-		resources: z
-			.object({
-				memory: z.string().optional().describe('Memory limit (e.g., "512Mi", "1Gi")'),
-				cpu: z.string().optional().describe('CPU limit (e.g., "0.5", "1")'),
-				disk: z.string().optional().describe('Disk size limit (e.g., "1Gi", "10Gi")'),
-			})
-			.optional()
-			.describe('Resource constraints for the sandbox'),
-		env: z
-			.record(z.string(), z.string())
-			.optional()
-			.describe('Environment variables to set in the sandbox'),
-		network: z
-			.object({
-				enabled: z.boolean().optional().describe('Whether network access is enabled'),
-				port: z
-					.number()
-					.int()
-					.min(1024)
-					.max(65535)
-					.optional()
-					.describe('Port to expose from the sandbox (1024-65535)'),
-			})
-			.optional()
-			.describe('Network configuration for the sandbox'),
-		stream: z
-			.object({
-				stdout: z.string().optional().describe('Stream ID for stdout output'),
-				stderr: z.string().optional().describe('Stream ID for stderr output'),
-				stdin: z.string().optional().describe('Stream ID for stdin input'),
-				timestamps: z.boolean().optional().describe('Whether to include timestamps in output'),
-			})
-			.optional()
-			.describe('Stream configuration for I/O redirection'),
-		timeout: z
-			.object({
-				idle: z.string().optional().describe('Idle timeout duration (e.g., "5m", "1h")'),
-				execution: z.string().optional().describe('Maximum execution time (e.g., "30m", "2h")'),
-			})
-			.optional()
-			.describe('Timeout settings for the sandbox'),
-		command: z
-			.object({
-				exec: z.array(z.string()).describe('Command and arguments to execute'),
-				files: z
-					.array(
-						z.object({
-							path: z
-								.string()
-								.describe('Path to the file relative to the sandbox workspace'),
-							content: z.string().describe('Base64-encoded file content'),
-						})
-					)
-					.optional()
-					.describe('Files to write before execution (deprecated: use top-level files)'),
-				mode: z
-					.enum(['oneshot', 'interactive'])
-					.optional()
-					.describe('Execution mode: oneshot runs once, interactive keeps running'),
-			})
-			.optional()
-			.describe('Initial command to run in the sandbox'),
-		files: z
-			.array(
-				z.object({
-					path: z.string().describe('Path to the file relative to the sandbox workspace'),
-					content: z.string().describe('Base64-encoded file content'),
-				})
-			)
-			.optional()
-			.describe('Files to write to sandbox on creation'),
-		snapshot: z.string().optional().describe('Snapshot ID to restore the sandbox from'),
-		dependencies: z
-			.array(z.string())
-			.optional()
-			.describe('Apt packages to install when creating the sandbox'),
-		packages: z
-			.array(
-				z
-					.string()
-					.regex(
-						NPM_PACKAGE_NAME_PATTERN,
-						'Invalid npm/bun package specifier: must not contain whitespace, semicolons, backticks, pipes, or dollar signs'
-					)
-			)
-			.optional()
-			.describe('npm/bun packages to install globally when creating the sandbox'),
-		metadata: z
-			.record(z.string(), z.unknown())
-			.optional()
-			.describe('Optional user-defined metadata to associate with the sandbox'),
-	})
-	.refine(
-		(data) => {
-			// If snapshot is provided, runtime and runtimeId must not be provided
-			if (data.snapshot) {
-				return !data.runtime && !data.runtimeId;
-			}
-			return true;
-		},
-		{
-			message: 'cannot specify both snapshot and runtime; snapshot includes its own runtime',
-			path: ['snapshot'],
-		}
-	)
-	.describe('Request body for creating a new sandbox');
-
-export const SandboxCreateDataSchema = z
-	.object({
-		sandboxId: z.string().describe('Unique identifier for the created sandbox'),
-		status: z
-			.enum([
-				'creating',
-				'idle',
-				'running',
-				'paused',
-				'stopping',
-				'suspended',
-				'terminated',
-				'failed',
-			])
-			.describe('Current status of the sandbox'),
-		stdoutStreamId: z.string().optional().describe('Stream ID for reading stdout'),
-		stdoutStreamUrl: z.string().optional().describe('URL for streaming stdout output'),
-		stderrStreamId: z.string().optional().describe('Stream ID for reading stderr'),
-		stderrStreamUrl: z.string().optional().describe('URL for streaming stderr output'),
-		auditStreamId: z.string().optional().describe('Stream ID for reading audit events'),
-		auditStreamUrl: z.string().optional().describe('URL for streaming audit events'),
-	})
-	.describe('Response data from sandbox creation');
-
-export const SandboxCreateResponseSchema = APIResponseSchema(SandboxCreateDataSchema);
-
-export interface SandboxCreateResponse {
-	sandboxId: string;
-	status: SandboxStatus;
-	stdoutStreamId?: string;
-	stdoutStreamUrl?: string;
-	stderrStreamId?: string;
-	stderrStreamUrl?: string;
-	auditStreamId?: string;
-	auditStreamUrl?: string;
-}
-
-export interface SandboxCreateParams {
-	options?: SandboxCreateOptions;
-	orgId?: string;
-}
-
-/**
- * Creates a new sandbox instance.
- *
- * @param client - The API client to use for the request
- * @param params - Parameters for creating the sandbox
- * @returns The created sandbox response including sandbox ID and stream URLs
- * @throws {SandboxResponseError} If the sandbox creation fails
- */
-export async function sandboxCreate(
-	client: APIClient,
-	params: SandboxCreateParams = {}
-): Promise<SandboxCreateResponse> {
-	const { options = {}, orgId } = params;
-	const body: z.infer<typeof SandboxCreateRequestSchema> = {};
-
-	if (options.projectId) {
-		body.projectId = options.projectId;
-	}
-	if (options.runtime) {
-		body.runtime = options.runtime;
-	}
-	if (options.runtimeId) {
-		body.runtimeId = options.runtimeId;
-	}
-	if (options.name) {
-		body.name = options.name;
-	}
-	if (options.description) {
-		body.description = options.description;
-	}
-	if (options.resources) {
-		body.resources = options.resources;
-	}
-	if (options.env) {
-		body.env = options.env;
-	}
-	if (options.network) {
-		body.network = options.network;
-	}
-	if (options.stream) {
-		body.stream = options.stream;
-	}
-	if (options.timeout) {
-		body.timeout = options.timeout;
-	}
-	if (options.command) {
-		body.command = {
-			exec: options.command.exec,
-			mode: options.command.mode,
-			files: options.command.files?.map((f) => ({
-				path: f.path,
-				content: f.content.toString('base64'),
-			})),
-		};
-	}
-	if (options.files && options.files.length > 0) {
-		body.files = options.files.map((f) => ({
-			path: f.path,
-			content: f.content.toString('base64'),
-		}));
-	}
-	if (options.snapshot) {
-		body.snapshot = options.snapshot;
-	}
-	if (options.dependencies && options.dependencies.length > 0) {
-		body.dependencies = options.dependencies;
-	}
-	if (options.packages && options.packages.length > 0) {
-		body.packages = options.packages;
-	}
-	if (options.metadata) {
-		body.metadata = options.metadata;
-	}
-
-	const queryParams = new URLSearchParams();
-	if (orgId) {
-		queryParams.set('orgId', orgId);
-	}
-	const queryString = queryParams.toString();
-	const url = `/sandbox/${API_VERSION}${queryString ? `?${queryString}` : ''}`;
-
-	const resp = await client.post<z.infer<typeof SandboxCreateResponseSchema>>(
-		url,
-		body,
-		SandboxCreateResponseSchema,
-		SandboxCreateRequestSchema
-	);
-
-	if (resp.success) {
-		return resp.data;
-	}
-
-	throwSandboxError(resp, {});
-}

package/src/api/sandbox/destroy.ts

@@ -1,41 +0,0 @@
-import type { z } from 'zod';
-import { type APIClient, APIResponseSchemaNoData } from '../api.ts';
-import { API_VERSION, throwSandboxError } from './util.ts';
-
-export const DestroyResponseSchema = APIResponseSchemaNoData();
-
-export interface SandboxDestroyParams {
-	sandboxId: string;
-	orgId?: string;
-}
-
-/**
- * Destroys a sandbox and releases all associated resources.
- *
- * @param client - The API client to use for the request
- * @param params - Parameters including the sandbox ID to destroy
- * @throws {SandboxResponseError} If the sandbox is not found or destruction fails
- */
-export async function sandboxDestroy(
-	client: APIClient,
-	params: SandboxDestroyParams
-): Promise<void> {
-	const { sandboxId, orgId } = params;
-	const queryParams = new URLSearchParams();
-	if (orgId) {
-		queryParams.set('orgId', orgId);
-	}
-	const queryString = queryParams.toString();
-	const url = `/sandbox/${API_VERSION}/${sandboxId}${queryString ? `?${queryString}` : ''}`;
-
-	const resp = await client.delete<z.infer<typeof DestroyResponseSchema>>(
-		url,
-		DestroyResponseSchema
-	);
-
-	if (resp.success) {
-		return;
-	}
-
-	throwSandboxError(resp, { sandboxId });
-}

package/src/api/sandbox/disk-checkpoint.ts

@@ -1,179 +0,0 @@
-import { z } from 'zod';
-import type { z as zType } from 'zod';
-import { type APIClient, APIResponseSchema, APIResponseSchemaNoData } from '../api';
-import { API_VERSION, throwSandboxError } from './util';
-
-// --- Schemas ---
-
-export const DiskCheckpointInfoSchema = z.object({
-	id: z.string().describe('Globally unique checkpoint ID (ckpt_xxx)'),
-	name: z.string().describe('User-provided checkpoint name'),
-	createdAt: z.string().describe('ISO timestamp of creation'),
-	parent: z.string().describe('Parent checkpoint name (empty for base)'),
-});
-
-export type DiskCheckpointInfo = z.infer<typeof DiskCheckpointInfoSchema>;
-
-const CreateDiskCheckpointDataSchema = DiskCheckpointInfoSchema;
-export const CreateDiskCheckpointResponseSchema = APIResponseSchema(CreateDiskCheckpointDataSchema);
-
-const ListDiskCheckpointsDataSchema = z.object({
-	checkpoints: z.array(DiskCheckpointInfoSchema),
-});
-export const ListDiskCheckpointsResponseSchema = APIResponseSchema(ListDiskCheckpointsDataSchema);
-
-export const RestoreDiskCheckpointResponseSchema = APIResponseSchemaNoData();
-export const DeleteDiskCheckpointResponseSchema = APIResponseSchemaNoData();
-
-// --- Params ---
-
-export interface DiskCheckpointCreateParams {
-	sandboxId: string;
-	name: string;
-	orgId?: string;
-}
-
-export interface DiskCheckpointListParams {
-	sandboxId: string;
-	orgId?: string;
-}
-
-export interface DiskCheckpointRestoreParams {
-	sandboxId: string;
-	checkpointId: string;
-	orgId?: string;
-}
-
-export interface DiskCheckpointDeleteParams {
-	sandboxId: string;
-	checkpointId: string;
-	orgId?: string;
-}
-
-// --- API Functions ---
-
-/**
- * Creates a new disk checkpoint for a sandbox.
- *
- * @param client - The API client to use for the request
- * @param params - Parameters including the sandbox ID and checkpoint name
- * @throws {SandboxResponseError} If the sandbox is not found or checkpoint creation fails
- */
-export async function diskCheckpointCreate(
-	client: APIClient,
-	params: DiskCheckpointCreateParams
-): Promise<DiskCheckpointInfo> {
-	const { sandboxId, name, orgId } = params;
-	const queryParams = new URLSearchParams();
-	if (orgId) {
-		queryParams.set('orgId', orgId);
-	}
-	const queryString = queryParams.toString();
-	const url = `/sandbox/${API_VERSION}/${encodeURIComponent(sandboxId)}/checkpoint${queryString ? `?${queryString}` : ''}`;
-
-	const resp = await client.post<zType.infer<typeof CreateDiskCheckpointResponseSchema>>(
-		url,
-		{ name },
-		CreateDiskCheckpointResponseSchema
-	);
-
-	if (resp.success) {
-		return resp.data;
-	}
-
-	throwSandboxError(resp, { sandboxId });
-}
-
-/**
- * Lists all disk checkpoints for a sandbox.
- *
- * @param client - The API client to use for the request
- * @param params - Parameters including the sandbox ID
- * @throws {SandboxResponseError} If the sandbox is not found or listing fails
- */
-export async function diskCheckpointList(
-	client: APIClient,
-	params: DiskCheckpointListParams
-): Promise<DiskCheckpointInfo[]> {
-	const { sandboxId, orgId } = params;
-	const queryParams = new URLSearchParams();
-	if (orgId) {
-		queryParams.set('orgId', orgId);
-	}
-	const queryString = queryParams.toString();
-	const url = `/sandbox/${API_VERSION}/checkpoints/${encodeURIComponent(sandboxId)}${queryString ? `?${queryString}` : ''}`;
-
-	const resp = await client.get<zType.infer<typeof ListDiskCheckpointsResponseSchema>>(
-		url,
-		ListDiskCheckpointsResponseSchema
-	);
-
-	if (resp.success) {
-		return resp.data.checkpoints;
-	}
-
-	throwSandboxError(resp, { sandboxId });
-}
-
-/**
- * Restores a sandbox to a specific disk checkpoint.
- *
- * @param client - The API client to use for the request
- * @param params - Parameters including the sandbox ID and checkpoint ID
- * @throws {SandboxResponseError} If the sandbox or checkpoint is not found, or restore fails
- */
-export async function diskCheckpointRestore(
-	client: APIClient,
-	params: DiskCheckpointRestoreParams
-): Promise<void> {
-	const { sandboxId, checkpointId, orgId } = params;
-	const queryParams = new URLSearchParams();
-	if (orgId) {
-		queryParams.set('orgId', orgId);
-	}
-	const queryString = queryParams.toString();
-	const url = `/sandbox/${API_VERSION}/${encodeURIComponent(sandboxId)}/checkpoint/${encodeURIComponent(checkpointId)}/restore${queryString ? `?${queryString}` : ''}`;
-
-	const resp = await client.post<zType.infer<typeof RestoreDiskCheckpointResponseSchema>>(
-		url,
-		undefined,
-		RestoreDiskCheckpointResponseSchema
-	);
-
-	if (resp.success) {
-		return;
-	}
-
-	throwSandboxError(resp, { sandboxId });
-}
-
-/**
- * Deletes a disk checkpoint from a sandbox.
- *
- * @param client - The API client to use for the request
- * @param params - Parameters including the sandbox ID and checkpoint ID
- * @throws {SandboxResponseError} If the sandbox or checkpoint is not found, or deletion fails
- */
-export async function diskCheckpointDelete(
-	client: APIClient,
-	params: DiskCheckpointDeleteParams
-): Promise<void> {
-	const { sandboxId, checkpointId, orgId } = params;
-	const queryParams = new URLSearchParams();
-	if (orgId) {
-		queryParams.set('orgId', orgId);
-	}
-	const queryString = queryParams.toString();
-	const url = `/sandbox/${API_VERSION}/${encodeURIComponent(sandboxId)}/checkpoint/${encodeURIComponent(checkpointId)}${queryString ? `?${queryString}` : ''}`;
-
-	const resp = await client.delete<zType.infer<typeof DeleteDiskCheckpointResponseSchema>>(
-		url,
-		DeleteDiskCheckpointResponseSchema
-	);
-
-	if (resp.success) {
-		return;
-	}
-
-	throwSandboxError(resp, { sandboxId });
-}