@agentuity/server 1.0.32 → 1.0.33

package/src/api/db/index.ts

@@ -1,27 +0,0 @@
-export {
-	DbLogsAPIResponseSchema,
-	DbLogsRequestSchema,
-	DbLogsResponseSchema,
-	type DbQueryLog,
-	DbQueryLogSchema,
-	type DbQueryLogs,
-	dbLogs,
-} from './logs.ts';
-export {
-	dbQuery,
-	type QueryColumn,
-	QueryColumnSchema,
-	QueryResponseSchema,
-	type QueryResult,
-	QueryResultSchema,
-} from './query.ts';
-export {
-	dbTables,
-	generateCreateTableSQL,
-	type TableColumn,
-	TableColumnSchema,
-	type TableSchema,
-	TableSchemaSchema,
-	TablesResponseSchema,
-} from './tables.ts';
-export { DbInvalidArgumentError, DbResponseError } from './util.ts';

package/src/api/db/logs.ts

@@ -1,75 +0,0 @@
-import { z } from 'zod';
-import { type APIClient, APIResponseSchema } from '../api.ts';
-import { DbInvalidArgumentError, DbResponseError } from './util.ts';
-
-export const DbLogsRequestSchema = z.object({
-	database: z.string().describe('the database name'),
-	orgId: z.string().describe('the organization ID'),
-	region: z.string().describe('the region'),
-	startDate: z.string().optional().describe('start date filter'),
-	endDate: z.string().optional().describe('end date filter'),
-	username: z.string().optional().describe('username filter'),
-	command: z.string().optional().describe('command filter'),
-	hasError: z.boolean().optional().describe('filter by error status'),
-	sessionId: z.string().optional().describe('filter by session ID (trace ID)'),
-	limit: z.number().optional().describe('maximum number of logs to return'),
-});
-
-export const DbQueryLogSchema = z.object({
-	timestamp: z.string().describe('log timestamp'),
-	username: z.string().describe('username'),
-	database: z.string().describe('database name'),
-	duration: z.number().describe('query duration in milliseconds'),
-	txStatus: z.string().describe('transaction status'),
-	command: z.string().describe('SQL command type'),
-	rowCount: z.number().describe('number of rows affected'),
-	sql: z.string().describe('SQL query'),
-	error: z.string().optional().describe('error message if any'),
-	sessionId: z.string().optional().describe('session ID with sess_ prefix'),
-});
-
-export const DbLogsResponseSchema = z.array(DbQueryLogSchema);
-
-export const DbLogsAPIResponseSchema = APIResponseSchema(DbLogsResponseSchema);
-
-type DbLogsRequest = z.infer<typeof DbLogsRequestSchema>;
-type DbLogsAPIResponse = z.infer<typeof DbLogsAPIResponseSchema>;
-
-export type DbQueryLog = z.infer<typeof DbQueryLogSchema>;
-export type DbQueryLogs = DbQueryLog[];
-
-/**
- * Get query logs for a database from the App API
- *
- * @param client APIClient configured for the App API base URL
- * @param request
- * @returns
- */
-export async function dbLogs(client: APIClient, request: DbLogsRequest): Promise<DbQueryLogs> {
-	const { database, orgId, region, ...filters } = request;
-
-	if (!orgId || !region) {
-		throw new DbInvalidArgumentError({ message: 'orgId and region are required', orgId, region });
-	}
-
-	const params = new URLSearchParams();
-	Object.entries(filters).forEach(([key, value]) => {
-		if (value !== undefined) {
-			params.append(key, String(value));
-		}
-	});
-
-	const queryString = params.toString();
-	const url = `/resource/2025-03-17/${orgId}/${region}/${database}/logs${queryString ? `?${queryString}` : ''}`;
-
-	const resp = await client.get<DbLogsAPIResponse>(url, DbLogsAPIResponseSchema);
-
-	if (resp.success) {
-		return resp.data;
-	}
-
-	throw new DbResponseError({
-		database,
-		message: resp.message || 'Failed to fetch database logs',
-	});
-}

package/src/api/db/query.ts

@@ -1,67 +0,0 @@
-import { z } from 'zod';
-import { APIClient, APIError } from '../api.ts';
-import { DbInvalidArgumentError, DbResponseError } from './util.ts';
-
-export const QueryColumnSchema = z.object({
-	name: z.string().describe('column name'),
-	type: z.string().describe('PostgreSQL data type OID'),
-});
-
-export const QueryResultSchema = z.object({
-	columns: z.array(QueryColumnSchema).describe('column metadata'),
-	rows: z.array(z.record(z.string(), z.any())).describe('query result rows'),
-	rowCount: z.number().describe('number of rows returned'),
-	truncated: z.boolean().describe('whether results were truncated (max 1000 rows)'),
-});
-
-export const QueryResponseSchema = z.object({
-	success: z.boolean(),
-	message: z.string().optional(),
-	data: QueryResultSchema.optional(),
-});
-
-export type QueryColumn = z.infer<typeof QueryColumnSchema>;
-export type QueryResult = z.infer<typeof QueryResultSchema>;
-
-interface DbQueryRequest {
-	database: string;
-	query: string;
-	orgId: string;
-	region: string;
-}
-
-export async function dbQuery(client: APIClient, request: DbQueryRequest): Promise<QueryResult> {
-	const { database, query, orgId, region } = request;
-
-	if (!orgId || !region) {
-		throw new DbInvalidArgumentError({ message: 'orgId and region are required', orgId, region });
-	}
-
-	if (!query) {
-		throw new DbInvalidArgumentError({ message: 'query is required', query });
-	}
-
-	const url = `/resource/2025-03-17/${orgId}/${region}/${database}/query`;
-
-	try {
-		const resp = await client.post(url, { query }, QueryResponseSchema);
-
-		if (resp.success && resp.data) {
-			return resp.data;
-		}
-
-		throw new DbResponseError({
-			database,
-			message: resp.message ?? 'Failed to execute database query',
-		});
-	} catch (ex) {
-		if (ex instanceof APIError) {
-			let message = ex.message;
-			if (message?.startsWith('failed to execute query: ')) {
-				message = message.substring(25);
-			}
-			throw new DbResponseError({ database, message });
-		}
-		throw ex;
-	}
-}

package/src/api/db/tables.ts

@@ -1,92 +0,0 @@
-import { z } from 'zod';
-import { type APIClient, APIResponseSchema } from '../api.ts';
-import { DbInvalidArgumentError, DbResponseError } from './util.ts';
-
-export const TableColumnSchema = z.object({
-	name: z.string().describe('column name'),
-	data_type: z.string().describe('PostgreSQL data type'),
-	is_nullable: z.boolean().describe('whether the column is nullable'),
-	default_value: z.string().optional().describe('default value'),
-	is_primary_key: z.boolean().describe('whether this column is part of the primary key'),
-});
-
-export const TableSchemaSchema = z.object({
-	table_name: z.string().describe('table name'),
-	columns: z.array(TableColumnSchema).describe('table columns'),
-});
-
-export const TablesResponseSchema = APIResponseSchema(
-	z.object({
-		tables: z.array(TableSchemaSchema),
-	})
-);
-
-export type TableColumn = z.infer<typeof TableColumnSchema>;
-export type TableSchema = z.infer<typeof TableSchemaSchema>;
-
-interface DbTablesRequest {
-	database: string;
-	orgId: string;
-	region: string;
-}
-
-export async function dbTables(
-	client: APIClient,
-	request: DbTablesRequest
-): Promise<TableSchema[]> {
-	const { database, orgId, region } = request;
-
-	if (!orgId || !region) {
-		throw new DbInvalidArgumentError({ message: 'orgId and region are required', orgId, region });
-	}
-
-	const url = `/resource/2025-03-17/${orgId}/${region}/${database}/tables`;
-
-	const resp = await client.get(url, TablesResponseSchema);
-
-	if (resp.success) {
-		return resp.data.tables;
-	}
-
-	throw new DbResponseError({
-		database,
-		message: resp.message || 'Failed to fetch database tables',
-	});
-}
-
-export function generateCreateTableSQL(table: TableSchema): string {
-	const lines: string[] = [`CREATE TABLE ${table.table_name} (`];
-
-	// Collect primary key columns
-	const primaryKeyColumns: string[] = [];
-
-	const columnDefs = table.columns.map((col) => {
-		let def = `    ${col.name} ${col.data_type}`;
-
-		if (!col.is_nullable) {
-			def += ' NOT NULL';
-		}
-
-		if (col.default_value) {
-			def += ` DEFAULT ${col.default_value}`;
-		}
-
-		if (col.is_primary_key) {
-			primaryKeyColumns.push(col.name);
-		}
-
-		return def;
-	});
-
-	lines.push(columnDefs.join(',\n'));
-
-	// Add table-level PRIMARY KEY constraint if any columns are marked as primary keys
-	if (primaryKeyColumns.length > 0) {
-		lines.push(',');
-		lines.push(`    PRIMARY KEY (${primaryKeyColumns.join(', ')})`);
-	}
-
-	lines.push(');');
-
-	return lines.join('\n');
-}

package/src/api/db/util.ts

@@ -1,9 +0,0 @@
-import { StructuredError } from '@agentuity/core';
-
-export const DbResponseError = StructuredError('DbResponseError')<{ database: string }>();
-
-export const DbInvalidArgumentError = StructuredError('DbInvalidArgumentError')<{
-	orgId?: string;
-	region?: string;
-	query?: string;
-}>();

package/src/api/eval/get.ts

@@ -1,33 +0,0 @@
-import { z } from 'zod';
-import { type APIClient, APIResponseSchema } from '../api.ts';
-
-export const EvaluationDetailSchema = z.object({
-	id: z.string().describe('Evaluation ID'),
-	name: z.string().describe('Evaluation name'),
-	description: z.string().nullable().describe('Evaluation description'),
-	identifier: z.string().nullable().describe('Stable evaluation identifier'),
-	agentIdentifier: z.string().describe('Agent identifier'),
-	projectId: z.string().describe('Project ID'),
-	orgId: z.string().describe('Organization ID'),
-	devmode: z.boolean().describe('Whether this is a devmode evaluation'),
-	createdAt: z.string().describe('Creation timestamp'),
-	updatedAt: z.string().describe('Last updated timestamp'),
-});
-
-export const EvalGetResponseSchema = APIResponseSchema(EvaluationDetailSchema);
-
-export type EvaluationDetail = z.infer<typeof EvaluationDetailSchema>;
-
-export async function evalGet(client: APIClient, id: string): Promise<EvaluationDetail> {
-	const resp = await client.request<z.infer<typeof EvalGetResponseSchema>>(
-		'GET',
-		`/cli/eval/${encodeURIComponent(id)}`,
-		EvalGetResponseSchema
-	);
-
-	if (resp.success) {
-		return resp.data;
-	}
-
-	throw new Error(resp.message || 'Failed to get evaluation');
-}

package/src/api/eval/index.ts

@@ -1,28 +0,0 @@
-export {
-	EvalGetResponseSchema,
-	type EvaluationDetail,
-	EvaluationDetailSchema,
-	evalGet,
-} from './get.ts';
-export {
-	EvalListResponseData,
-	EvalListResponseSchema,
-	type Evaluation,
-	type EvaluationListRequest,
-	EvaluationSchema,
-	evalList,
-} from './list.ts';
-export {
-	type EvalRunDetail,
-	EvalRunDetailSchema,
-	EvalRunGetResponseSchema,
-	evalRunGet,
-} from './run-get.ts';
-export {
-	type EvalRunListItem,
-	type EvalRunListRequest,
-	EvalRunListResponseData,
-	EvalRunListResponseSchema,
-	EvalRunSchema,
-	evalRunList,
-} from './run-list.ts';

package/src/api/eval/list.ts

@@ -1,49 +0,0 @@
-import { z } from 'zod';
-import { type APIClient, APIResponseSchema } from '../api.ts';
-
-export const EvaluationSchema = z.object({
-	id: z.string().describe('Evaluation ID'),
-	name: z.string().describe('Evaluation name'),
-	description: z.string().nullable().describe('Evaluation description'),
-	identifier: z.string().nullable().describe('Stable evaluation identifier'),
-	agentIdentifier: z.string().describe('Agent identifier'),
-	projectId: z.string().describe('Project ID'),
-	devmode: z.boolean().describe('Whether this is a devmode evaluation'),
-	createdAt: z.string().describe('Creation timestamp'),
-	updatedAt: z.string().describe('Last updated timestamp'),
-});
-
-export const EvalListResponseData = z.array(EvaluationSchema);
-export const EvalListResponseSchema = APIResponseSchema(EvalListResponseData);
-
-export type Evaluation = z.infer<typeof EvaluationSchema>;
-export type EvaluationListRequest = {
-	projectId?: string;
-	agentId?: string;
-	orgId?: string;
-};
-
-export async function evalList(
-	client: APIClient,
-	request: EvaluationListRequest = {}
-): Promise<Evaluation[]> {
-	const params = new URLSearchParams();
-	if (request.orgId) params.set('orgId', request.orgId);
-	if (request.projectId) params.set('projectId', request.projectId);
-	if (request.agentId) params.set('agentId', request.agentId);
-
-	const queryString = params.toString();
-	const url = `/cli/eval${queryString ? `?${queryString}` : ''}`;
-
-	const resp = await client.request<z.infer<typeof EvalListResponseSchema>>(
-		'GET',
-		url,
-		EvalListResponseSchema
-	);
-
-	if (resp.success) {
-		return resp.data;
-	}
-
-	throw new Error(resp.message || 'Failed to list evaluations');
-}

package/src/api/eval/run-get.ts

@@ -1,39 +0,0 @@
-import { z } from 'zod';
-import { type APIClient, APIResponseSchema } from '../api.ts';
-
-export const EvalRunDetailSchema = z.object({
-	id: z.string().describe('Eval run ID'),
-	sessionId: z.string().describe('Session ID'),
-	evalId: z.string().describe('Evaluation record ID'),
-	evalIdentifier: z.string().nullable().describe('Stable evaluation identifier'),
-	evalName: z.string().nullable().describe('Evaluation name'),
-	agentIdentifier: z.string().nullable().describe('Agent identifier'),
-	projectId: z.string().describe('Project ID'),
-	orgId: z.string().describe('Organization ID'),
-	deploymentId: z.string().nullable().describe('Deployment ID'),
-	devmode: z.boolean().describe('Whether this is a devmode run'),
-	pending: z.boolean().describe('Whether the eval run is pending'),
-	success: z.boolean().describe('Whether the eval run succeeded'),
-	error: z.string().nullable().describe('Error message if failed'),
-	result: z.any().nullable().describe('Eval run result'),
-	createdAt: z.string().describe('Creation timestamp'),
-	updatedAt: z.string().describe('Last updated timestamp'),
-});
-
-export const EvalRunGetResponseSchema = APIResponseSchema(EvalRunDetailSchema);
-
-export type EvalRunDetail = z.infer<typeof EvalRunDetailSchema>;
-
-export async function evalRunGet(client: APIClient, id: string): Promise<EvalRunDetail> {
-	const resp = await client.request<z.infer<typeof EvalRunGetResponseSchema>>(
-		'GET',
-		`/cli/eval-run/${encodeURIComponent(id)}`,
-		EvalRunGetResponseSchema
-	);
-
-	if (resp.success) {
-		return resp.data;
-	}
-
-	throw new Error(resp.message || 'Failed to get eval run');
-}

package/src/api/eval/run-list.ts

@@ -1,59 +0,0 @@
-import { z } from 'zod';
-import { type APIClient, APIResponseSchema } from '../api.ts';
-
-export const EvalRunSchema = z.object({
-	id: z.string().describe('Eval run ID'),
-	sessionId: z.string().describe('Session ID'),
-	evalId: z.string().describe('Evaluation record ID'),
-	evalIdentifier: z.string().nullable().describe('Stable evaluation identifier'),
-	evalName: z.string().nullable().describe('Evaluation name'),
-	agentIdentifier: z.string().nullable().describe('Agent identifier'),
-	projectId: z.string().describe('Project ID'),
-	deploymentId: z.string().nullable().describe('Deployment ID'),
-	devmode: z.boolean().describe('Whether this is a devmode run'),
-	pending: z.boolean().describe('Whether the eval run is pending'),
-	success: z.boolean().describe('Whether the eval run succeeded'),
-	error: z.string().nullable().describe('Error message if failed'),
-	result: z.any().nullable().describe('Eval run result'),
-	createdAt: z.string().describe('Creation timestamp'),
-	updatedAt: z.string().describe('Last updated timestamp'),
-});
-
-export const EvalRunListResponseData = z.array(EvalRunSchema);
-export const EvalRunListResponseSchema = APIResponseSchema(EvalRunListResponseData);
-
-export type EvalRunListItem = z.infer<typeof EvalRunSchema>;
-export type EvalRunListRequest = {
-	projectId?: string;
-	agentId?: string;
-	evalId?: string;
-	sessionId?: string;
-	orgId?: string;
-};
-
-export async function evalRunList(
-	client: APIClient,
-	request: EvalRunListRequest = {}
-): Promise<EvalRunListItem[]> {
-	const params = new URLSearchParams();
-	if (request.orgId) params.set('orgId', request.orgId);
-	if (request.projectId) params.set('projectId', request.projectId);
-	if (request.agentId) params.set('agentId', request.agentId);
-	if (request.evalId) params.set('evalId', request.evalId);
-	if (request.sessionId) params.set('sessionId', request.sessionId);
-
-	const queryString = params.toString();
-	const url = `/cli/eval-run${queryString ? `?${queryString}` : ''}`;
-
-	const resp = await client.request<z.infer<typeof EvalRunListResponseSchema>>(
-		'GET',
-		url,
-		EvalRunListResponseSchema
-	);
-
-	if (resp.success) {
-		return resp.data;
-	}
-
-	throw new Error(resp.message || 'Failed to list eval runs');
-}

package/src/api/machine/index.ts

@@ -1,2 +0,0 @@
-export * from './machine.ts';
-export * from './util.ts';

package/src/api/machine/machine.ts

@@ -1,160 +0,0 @@
-import { z } from 'zod';
-import { APIResponseSchema, APIResponseSchemaNoData, APIClient } from '../api.ts';
-import { MachineResponseError } from './util.ts';
-
-// TODO: The old /cli/auth/machine/* endpoints should be aliased to redirect
-// to /cli/auth/org/* in the backend (app repo). Remove aliases in follow-up PR.
-
-export const MachineSchema = z.object({
-	id: z.string(),
-	instanceId: z.string().nullable().optional(),
-	privateIPv4: z.string().nullable().optional(),
-	availabilityZone: z.string().nullable().optional(),
-	instanceType: z.string().nullable().optional(),
-	instanceTags: z.array(z.string()).nullable().optional(),
-	deploymentCount: z.number().optional(),
-	status: z.string(),
-	provider: z.string(),
-	region: z.string(),
-	startedAt: z.string().nullable().optional(),
-	stoppedAt: z.string().nullable().optional(),
-	pausedAt: z.string().nullable().optional(),
-	erroredAt: z.string().nullable().optional(),
-	error: z.string().nullable().optional(),
-	orgId: z.string().nullable().optional(),
-	orgName: z.string().nullable().optional(),
-	createdAt: z.string(),
-	updatedAt: z.string().nullable().optional(),
-	metadata: z.record(z.string(), z.unknown()).nullable().optional(),
-});
-
-export const MachineListResponseSchema = APIResponseSchema(z.array(MachineSchema));
-export const MachineGetResponseSchema = APIResponseSchema(MachineSchema);
-export const MachineDeleteResponseSchema = APIResponseSchemaNoData();
-
-export type Machine = z.infer<typeof MachineSchema>;
-
-export async function machineList(
-	client: APIClient,
-	options?: { orgId?: string }
-): Promise<Machine[]> {
-	const headers = options?.orgId ? { 'x-agentuity-orgid': options.orgId } : undefined;
-	const resp = await client.get('/machine', MachineListResponseSchema, undefined, headers);
-	if (resp.success) {
-		return resp.data;
-	}
-	throw new MachineResponseError({ message: resp.message });
-}
-
-export async function machineGet(client: APIClient, machineId: string): Promise<Machine> {
-	const resp = await client.get(`/machine/${machineId}`, MachineGetResponseSchema);
-	if (resp.success) {
-		return resp.data;
-	}
-	throw new MachineResponseError({ message: resp.message });
-}
-
-export async function machineDelete(client: APIClient, machineId: string): Promise<void> {
-	const resp = await client.delete(`/machine/${machineId}`, MachineDeleteResponseSchema);
-	if (!resp.success) {
-		throw new MachineResponseError({ message: resp.message });
-	}
-}
-
-export const MachineDeploymentProjectSchema = z.object({
-	id: z.string(),
-	name: z.string(),
-	identifier: z.string(),
-	domains: z.array(z.string()),
-});
-
-export type MachineDeploymentProject = z.infer<typeof MachineDeploymentProjectSchema>;
-
-export const MachineDeploymentResourcesSchema = z.object({
-	cpuUnits: z.number(),
-	memoryUnits: z.number(),
-	diskUnits: z.number(),
-});
-
-export type MachineDeploymentResources = z.infer<typeof MachineDeploymentResourcesSchema>;
-
-export const MachineDeploymentSchema = z.object({
-	id: z.string(),
-	identifier: z.string().optional(),
-	state: z.string().optional(),
-	project: MachineDeploymentProjectSchema.nullable().optional(),
-	resources: MachineDeploymentResourcesSchema.nullable().optional(),
-	customDomains: z.array(z.string()),
-	paused: z.boolean(),
-	pausedDuration: z.number(),
-	domainSuffix: z.string(),
-});
-
-export const MachineDeploymentsResponseSchema = APIResponseSchema(z.array(MachineDeploymentSchema));
-
-export type MachineDeployment = z.infer<typeof MachineDeploymentSchema>;
-
-export async function machineDeployments(
-	client: APIClient,
-	machineId: string
-): Promise<MachineDeployment[]> {
-	const resp = await client.get(
-		`/machine/deployments/${machineId}`,
-		MachineDeploymentsResponseSchema
-	);
-	if (resp.success) {
-		return resp.data;
-	}
-	throw new MachineResponseError({ message: resp.message });
-}
-
-export const OrgAuthEnrollResponseSchema = APIResponseSchema(
-	z.object({
-		orgId: z.string(),
-	})
-);
-
-export async function orgAuthEnroll(
-	client: APIClient,
-	orgId: string,
-	publicKey: string
-): Promise<{ orgId: string }> {
-	const resp = await client.post(
-		'/cli/auth/org/enroll',
-		{ orgId, publicKey },
-		OrgAuthEnrollResponseSchema
-	);
-	if (resp.success) {
-		return resp.data;
-	}
-	throw new MachineResponseError({ message: resp.message });
-}
-
-export const OrgAuthStatusResponseSchema = APIResponseSchema(
-	z.object({
-		publicKey: z.string().nullable(),
-	})
-);
-
-export async function orgAuthStatus(
-	client: APIClient,
-	orgId: string
-): Promise<{ publicKey: string | null }> {
-	const resp = await client.get(`/cli/auth/org/status/${orgId}`, OrgAuthStatusResponseSchema);
-	if (resp.success) {
-		return resp.data;
-	}
-	throw new MachineResponseError({ message: resp.message });
-}
-
-export const OrgAuthUnenrollResponseSchema = APIResponseSchemaNoData();
-
-export async function orgAuthUnenroll(client: APIClient, orgId: string): Promise<void> {
-	const resp = await client.delete(
-		`/cli/auth/org/unenroll/${orgId}`,
-		OrgAuthUnenrollResponseSchema
-	);
-	if (!resp.success) {
-		throw new MachineResponseError({ message: resp.message });
-	}
-}

package/src/api/machine/util.ts

@@ -1,5 +0,0 @@
-import { StructuredError } from '@agentuity/core';
-
-export const MachineResponseError = StructuredError('MachineResponseError')<{
-	message: string;
-}>();

package/src/api/org/index.ts

@@ -1,6 +0,0 @@
-export * from './env-delete.ts';
-export * from './env-get.ts';
-export * from './env-update.ts';
-export * from './list.ts';
-export * from './resources.ts';
-export * from './util.ts';