@inkeep/agents-api 0.0.0-dev-20260121145510

package/dist/domains/manage/routes/projects.js

@@ -0,0 +1,279 @@
+import manageDbClient_default from "../../../data/db/manageDbClient.js";
+import runDbClient_default from "../../../data/db/runDbClient.js";
+import { requireProjectPermission } from "../../../middleware/projectAccess.js";
+import { speakeasyOffsetLimitPagination } from "../../../utils/speakeasy.js";
+import { requirePermission } from "../../../middleware/requirePermission.js";
+import { OpenAPIHono, createRoute } from "@hono/zod-openapi";
+import { ErrorResponseSchema, PaginationQueryParamsSchema, ProjectApiInsertSchema, ProjectApiUpdateSchema, ProjectListResponse, ProjectResponse, TenantIdParamsSchema, TenantParamsSchema, cascadeDeleteByProject, commonGetErrorResponses, createApiError, createProject, createProjectMetadataAndBranch, deleteProject, deleteProjectWithBranch, doltCheckout, getProject, getProjectMainBranchName, isAuthzEnabled, listAccessibleProjectIds, listProjectsWithMetadataPaginated, removeProjectFromSpiceDb, syncProjectToSpiceDb, updateProject } from "@inkeep/agents-core";
+
+//#region src/domains/manage/routes/projects.ts
+const app = new OpenAPIHono();
+app.use("/", async (c, next) => {
+	if (c.req.method === "POST") return requirePermission({ project: ["create"] })(c, next);
+	return next();
+});
+app.use("/:id", async (c, next) => {
+	if (c.req.method === "GET") return requireProjectPermission("view")(c, next);
+	if (c.req.method === "PATCH") return requireProjectPermission("edit")(c, next);
+	if (c.req.method === "DELETE") return requireProjectPermission("edit")(c, next);
+	return next();
+});
+app.openapi(createRoute({
+	method: "get",
+	path: "/",
+	summary: "List Projects",
+	description: "List all projects within a tenant with pagination. When authorization is enabled, only returns projects the user has access to.",
+	operationId: "list-projects",
+	tags: ["Projects"],
+	request: {
+		params: TenantParamsSchema,
+		query: PaginationQueryParamsSchema
+	},
+	responses: {
+		200: {
+			description: "List of projects retrieved successfully",
+			content: { "application/json": { schema: ProjectListResponse } }
+		},
+		...commonGetErrorResponses
+	},
+	...speakeasyOffsetLimitPagination
+}), async (c) => {
+	const configDb = c.get("db");
+	const { tenantId } = c.req.valid("param");
+	const userId = c.get("userId");
+	const tenantRole = c.get("tenantRole") || "member";
+	const page = Number(c.req.query("page")) || 1;
+	const limit = Math.min(Number(c.req.query("limit")) || 10, 100);
+	let accessibleIds;
+	if (isAuthzEnabled(tenantId) && userId) {
+		const result$1 = await listAccessibleProjectIds({
+			tenantId,
+			userId,
+			orgRole: tenantRole
+		});
+		if (result$1 !== "all") accessibleIds = result$1;
+	}
+	const result = await listProjectsWithMetadataPaginated(runDbClient_default, configDb)({
+		tenantId,
+		pagination: {
+			page,
+			limit
+		},
+		projectIds: accessibleIds
+	});
+	const transformedData = result.data.map((project) => ({
+		id: project.id,
+		tenantId: project.tenantId,
+		name: project.name ?? project.id,
+		description: project.description,
+		models: project.models,
+		stopWhen: project.stopWhen,
+		createdAt: project.createdAt,
+		updatedAt: project.configUpdatedAt ?? project.createdAt
+	}));
+	return c.json({
+		data: transformedData,
+		pagination: result.pagination
+	});
+});
+app.openapi(createRoute({
+	method: "get",
+	path: "/{id}",
+	summary: "Get Project",
+	description: "Get a single project by ID",
+	operationId: "get-project-by-id",
+	tags: ["Projects"],
+	request: { params: TenantIdParamsSchema },
+	responses: {
+		200: {
+			description: "Project found",
+			content: { "application/json": { schema: ProjectResponse } }
+		},
+		...commonGetErrorResponses
+	}
+}), async (c) => {
+	const db = c.get("db");
+	const { tenantId, id } = c.req.valid("param");
+	const project = await getProject(db)({ scopes: {
+		tenantId,
+		projectId: id
+	} });
+	if (!project) throw createApiError({
+		code: "not_found",
+		message: "Project not found"
+	});
+	return c.json({ data: project });
+});
+app.openapi(createRoute({
+	method: "post",
+	path: "/",
+	summary: "Create Project",
+	description: "Create a new project. When authorization is enabled, the creator is automatically granted admin role.",
+	operationId: "create-project",
+	tags: ["Projects"],
+	request: {
+		params: TenantParamsSchema,
+		body: { content: { "application/json": { schema: ProjectApiInsertSchema } } }
+	},
+	responses: {
+		201: {
+			description: "Project created successfully",
+			content: { "application/json": { schema: ProjectResponse } }
+		},
+		409: {
+			description: "Project already exists",
+			content: { "application/json": { schema: ErrorResponseSchema } }
+		},
+		...commonGetErrorResponses
+	}
+}), async (c) => {
+	const configDb = c.get("db");
+	const userId = c.get("userId");
+	const { tenantId } = c.req.valid("param");
+	const body = c.req.valid("json");
+	try {
+		const runtimeProject = await createProjectMetadataAndBranch(runDbClient_default, configDb)({
+			tenantId,
+			projectId: body.id,
+			createdBy: userId
+		});
+		const projectMainBranch = getProjectMainBranchName(tenantId, body.id);
+		await doltCheckout(configDb)({ branch: projectMainBranch });
+		const newResolvedRef = {
+			type: "branch",
+			name: projectMainBranch,
+			hash: ""
+		};
+		c.set("resolvedRef", newResolvedRef);
+		const projectConfig = await createProject(configDb)({
+			tenantId,
+			...body
+		});
+		if (isAuthzEnabled(tenantId)) {
+			if (!userId) throw createApiError({
+				code: "unauthorized",
+				message: "User not found"
+			});
+			try {
+				await syncProjectToSpiceDb({
+					tenantId,
+					projectId: body.id,
+					creatorUserId: userId
+				});
+			} catch (syncError) {
+				console.warn("Failed to sync project to SpiceDB:", syncError);
+			}
+		}
+		return c.json({ data: {
+			...projectConfig,
+			mainBranchName: runtimeProject.mainBranchName
+		} }, 201);
+	} catch (error) {
+		if (error?.cause?.code === "23505" || error?.message?.includes("already exists")) throw createApiError({
+			code: "conflict",
+			message: "Project with this ID already exists"
+		});
+		throw error;
+	}
+});
+app.openapi(createRoute({
+	method: "patch",
+	path: "/{id}",
+	summary: "Update Project",
+	description: "Update an existing project",
+	operationId: "update-project",
+	tags: ["Projects"],
+	request: {
+		params: TenantIdParamsSchema,
+		body: { content: { "application/json": { schema: ProjectApiUpdateSchema } } }
+	},
+	responses: {
+		200: {
+			description: "Project updated successfully",
+			content: { "application/json": { schema: ProjectResponse } }
+		},
+		...commonGetErrorResponses
+	}
+}), async (c) => {
+	const db = c.get("db");
+	const { tenantId, id } = c.req.valid("param");
+	const body = c.req.valid("json");
+	const project = await updateProject(db)({
+		scopes: {
+			tenantId,
+			projectId: id
+		},
+		data: body
+	});
+	if (!project) throw createApiError({
+		code: "not_found",
+		message: "Project not found"
+	});
+	return c.json({ data: project });
+});
+app.openapi(createRoute({
+	method: "delete",
+	path: "/{id}",
+	summary: "Delete Project",
+	description: "Delete a project and its branch. Must be called from the main branch.",
+	operationId: "delete-project",
+	tags: ["Projects"],
+	request: { params: TenantIdParamsSchema },
+	responses: {
+		204: { description: "Project deleted successfully" },
+		409: {
+			description: "Cannot delete project with existing resources",
+			content: { "application/json": { schema: ErrorResponseSchema } }
+		},
+		...commonGetErrorResponses
+	}
+}), async (c) => {
+	const configDb = c.get("db");
+	const resolvedRef = c.get("resolvedRef");
+	const { tenantId, id } = c.req.valid("param");
+	const expectedMainBranch = `${tenantId}_${id}_main`;
+	if (resolvedRef?.name !== expectedMainBranch) throw createApiError({
+		code: "bad_request",
+		message: "Project deletion must be performed from the main branch"
+	});
+	try {
+		await cascadeDeleteByProject(runDbClient_default)({
+			scopes: {
+				tenantId,
+				projectId: id
+			},
+			fullBranchName: resolvedRef.name
+		});
+		await deleteProject(configDb)({ scopes: {
+			tenantId,
+			projectId: id
+		} });
+		await doltCheckout(configDb)({ branch: "main" });
+		if (!await deleteProjectWithBranch(runDbClient_default, manageDbClient_default)({
+			tenantId,
+			projectId: id
+		})) throw createApiError({
+			code: "not_found",
+			message: "Project not found"
+		});
+		if (isAuthzEnabled(tenantId)) try {
+			await removeProjectFromSpiceDb({
+				tenantId,
+				projectId: id
+			});
+		} catch (syncError) {
+			console.warn("Failed to remove project from SpiceDB:", syncError);
+		}
+		return c.body(null, 204);
+	} catch (error) {
+		if (error.message?.includes("Cannot delete project with existing resources")) throw createApiError({
+			code: "conflict",
+			message: "Cannot delete project with existing resources"
+		});
+		throw error;
+	}
+});
+var projects_default = app;
+
+//#endregion
+export { projects_default as default };

package/dist/domains/manage/routes/ref.d.ts

@@ -0,0 +1,9 @@
+import { ManageAppVariables } from "../../../types/app.js";
+import { OpenAPIHono } from "@hono/zod-openapi";
+
+//#region src/domains/manage/routes/ref.d.ts
+declare const app: OpenAPIHono<{
+  Variables: ManageAppVariables;
+}, {}, "/">;
+//#endregion
+export { app as default };

package/dist/domains/manage/routes/ref.js

@@ -0,0 +1,33 @@
+import { OpenAPIHono, createRoute, z } from "@hono/zod-openapi";
+import { ResolvedRefSchema, TenantProjectParamsSchema, commonGetErrorResponses, createApiError } from "@inkeep/agents-core";
+
+//#region src/domains/manage/routes/ref.ts
+const app = new OpenAPIHono();
+const ResolvedRefResponseSchema = z.object({ data: ResolvedRefSchema }).openapi("ResolvedRefResponse");
+app.openapi(createRoute({
+	method: "get",
+	path: "/resolve",
+	summary: "Resolve Ref",
+	description: "Resolve a ref string (branch name, tag name, or commit hash) to its full resolved ref with type and commit hash. Pass the ref as a query parameter.",
+	operationId: "resolve-ref",
+	tags: ["Refs"],
+	request: { params: TenantProjectParamsSchema },
+	responses: {
+		200: {
+			description: "Ref resolved successfully",
+			content: { "application/json": { schema: ResolvedRefResponseSchema } }
+		},
+		...commonGetErrorResponses
+	}
+}), async (c) => {
+	const resolvedRef = c.get("resolvedRef");
+	if (!resolvedRef) throw createApiError({
+		code: "not_found",
+		message: "Could not resolve ref"
+	});
+	return c.json({ data: resolvedRef });
+});
+var ref_default = app;
+
+//#endregion
+export { ref_default as default };

package/dist/domains/manage/routes/signoz.d.ts

@@ -0,0 +1,10 @@
+import { ManageAppVariables } from "../../../types/app.js";
+import { Hono } from "hono";
+import * as hono_types5 from "hono/types";
+
+//#region src/domains/manage/routes/signoz.d.ts
+declare const app: Hono<{
+  Variables: ManageAppVariables;
+}, hono_types5.BlankSchema, "/">;
+//#endregion
+export { app as default };

package/dist/domains/manage/routes/signoz.js

@@ -0,0 +1,159 @@
+import { getLogger as getLogger$1 } from "../../../logger.js";
+import { env } from "../../../env.js";
+import { enforceProjectFilter } from "../../../utils/signozHelpers.js";
+import { Hono } from "hono";
+import { createApiError, projectExists } from "@inkeep/agents-core";
+import axios from "axios";
+
+//#region src/domains/manage/routes/signoz.ts
+const logger = getLogger$1("signoz-proxy");
+const app = new Hono();
+app.post("/query", async (c) => {
+	let payload = await c.req.json();
+	const requestedProjectId = payload.projectId;
+	const tenantId = c.get("tenantId");
+	const db = c.get("db");
+	if (!tenantId) throw createApiError({
+		code: "unauthorized",
+		message: "Tenant ID not found"
+	});
+	logger.debug({
+		tenantId,
+		projectId: requestedProjectId,
+		hasProjectId: !!requestedProjectId
+	}, "Processing SigNoz query request");
+	if (requestedProjectId) {
+		if (!await projectExists(db)({
+			tenantId,
+			projectId: requestedProjectId
+		})) {
+			logger.warn({
+				tenantId,
+				projectId: requestedProjectId
+			}, "Project not found or access denied");
+			return c.json({
+				error: "Forbidden",
+				message: "You do not have access to this project"
+			}, 403);
+		}
+		payload = enforceProjectFilter(payload, requestedProjectId);
+		logger.debug({ projectId: requestedProjectId }, "Project filter enforced");
+	}
+	const signozUrl = env.SIGNOZ_URL || env.PUBLIC_SIGNOZ_URL;
+	const signozApiKey = env.SIGNOZ_API_KEY;
+	if (!signozUrl || !signozApiKey) {
+		logger.error({}, "SigNoz not configured");
+		return c.json({
+			error: "Service Unavailable",
+			message: "SigNoz is not configured"
+		}, 500);
+	}
+	try {
+		const signozEndpoint = `${signozUrl}/api/v4/query_range`;
+		logger.debug({ endpoint: signozEndpoint }, "Proxying to SigNoz");
+		const response = await axios.post(signozEndpoint, payload, {
+			headers: {
+				"Content-Type": "application/json",
+				"SIGNOZ-API-KEY": signozApiKey
+			},
+			timeout: 3e4
+		});
+		logger.debug({ status: response.status }, "SigNoz query successful");
+		return c.json(response.data);
+	} catch (error) {
+		if (axios.isAxiosError(error)) {
+			if (error.code === "ECONNREFUSED" || error.code === "ENOTFOUND") {
+				logger.error({ error: error.message }, "SigNoz service unavailable");
+				return c.json({
+					error: "Service Unavailable",
+					message: "SigNoz service is unavailable"
+				}, 503);
+			}
+			if (error.response?.status === 401 || error.response?.status === 403) {
+				logger.error({ status: error.response.status }, "SigNoz authentication failed");
+				return c.json({
+					error: "Internal Server Error",
+					message: "SigNoz authentication failed"
+				}, 500);
+			}
+			if (error.response?.status === 400) {
+				logger.warn({ status: error.response.status }, "Invalid SigNoz query");
+				return c.json({
+					error: "Bad Request",
+					message: "Invalid query parameters"
+				}, 400);
+			}
+		}
+		logger.error({ error }, "SigNoz query failed");
+		return c.json({
+			error: "Internal Server Error",
+			message: "Failed to query SigNoz"
+		}, 500);
+	}
+});
+app.get("/health", async (c) => {
+	const signozUrl = env.SIGNOZ_URL || env.PUBLIC_SIGNOZ_URL;
+	const signozApiKey = env.SIGNOZ_API_KEY;
+	logger.debug({
+		hasUrl: !!signozUrl,
+		hasApiKey: !!signozApiKey,
+		url: signozUrl
+	}, "Checking SigNoz configuration");
+	if (!signozUrl || !signozApiKey) {
+		logger.warn({}, "SigNoz credentials not set");
+		return c.json({
+			status: "not_configured",
+			configured: false,
+			error: "SIGNOZ_URL or SIGNOZ_API_KEY not set"
+		});
+	}
+	try {
+		const testPayload = {
+			start: Date.now() - 3e5,
+			end: Date.now(),
+			step: 60,
+			compositeQuery: {
+				queryType: "builder",
+				panelType: "table",
+				builderQueries: {}
+			}
+		};
+		const signozEndpoint = `${signozUrl}/api/v4/query_range`;
+		logger.debug({ endpoint: signozEndpoint }, "Testing SigNoz connection");
+		await axios.post(signozEndpoint, testPayload, {
+			headers: {
+				"Content-Type": "application/json",
+				"SIGNOZ-API-KEY": signozApiKey
+			},
+			timeout: 5e3,
+			validateStatus: (status) => status === 200 || status === 400
+		});
+		logger.debug({}, "SigNoz health check successful");
+		return c.json({
+			status: "ok",
+			configured: true
+		});
+	} catch (error) {
+		logger.error({
+			error,
+			message: error instanceof Error ? error.message : "Unknown error",
+			code: axios.isAxiosError(error) ? error.code : void 0,
+			status: axios.isAxiosError(error) ? error.response?.status : void 0
+		}, "SigNoz connection test failed");
+		let errorMessage = "Failed to connect to SigNoz";
+		if (axios.isAxiosError(error)) {
+			if (error.code === "ECONNREFUSED" || error.code === "ENOTFOUND") errorMessage = "Check SIGNOZ_URL";
+			else if (error.response?.status === 401 || error.response?.status === 403) errorMessage = "Invalid SIGNOZ_API_KEY";
+			else if (error.code === "ETIMEDOUT" || error.code === "ECONNABORTED") errorMessage = "SigNoz connection timed out";
+		}
+		return c.json({
+			status: "connection_failed",
+			configured: false,
+			error: errorMessage
+		});
+	}
+});
+var signoz_default = app;
+
+//#endregion
+export { signoz_default as default };

package/dist/domains/manage/routes/subAgentArtifactComponents.d.ts

@@ -0,0 +1,9 @@
+import { ManageAppVariables } from "../../../types/app.js";
+import { OpenAPIHono } from "@hono/zod-openapi";
+
+//#region src/domains/manage/routes/subAgentArtifactComponents.d.ts
+declare const app: OpenAPIHono<{
+  Variables: ManageAppVariables;
+}, {}, "/">;
+//#endregion
+export { app as default };