@inkeep/agents-manage-api 0.1.1 → 0.1.6

package/dist/routes/graphFull.js

@@ -1,248 +0,0 @@
-import { createRoute, OpenAPIHono } from '@hono/zod-openapi';
-import { z } from 'zod';
-import { commonGetErrorResponses, createApiError } from '@inkeep/agents-core';
-import { createFullGraphServerSide, deleteFullGraph, getFullGraph, updateFullGraphServerSide, ErrorResponseSchema, FullGraphDefinitionSchema, SingleResponseSchema, TenantProjectParamsSchema, } from '@inkeep/agents-core';
-import dbClient from '../data/db/dbClient.js';
-import { getLogger } from '../logger.js';
-const logger = getLogger('graphFull');
-const app = new OpenAPIHono();
-// Schema for path parameters with graphId
-const GraphIdParamsSchema = z
-    .object({
-    tenantId: z.string().openapi({
-        description: 'Tenant identifier',
-        example: 'tenant_123',
-    }),
-    projectId: z.string().openapi({
-        description: 'Project identifier',
-        example: 'project_456',
-    }),
-    graphId: z.string().openapi({
-        description: 'Graph identifier',
-        example: 'graph_789',
-    }),
-})
-    .openapi('GraphIdParams');
-// Create full graph from JSON
-app.openapi(createRoute({
-    method: 'post',
-    path: '/',
-    summary: 'Create Full Graph',
-    operationId: 'create-full-graph',
-    tags: ['CRUD Full Graph'],
-    description: 'Create a complete agent graph with all agents, tools, and relationships from JSON definition',
-    request: {
-        params: TenantProjectParamsSchema,
-        body: {
-            content: {
-                'application/json': {
-                    schema: FullGraphDefinitionSchema,
-                },
-            },
-        },
-    },
-    responses: {
-        201: {
-            description: 'Full graph created successfully',
-            content: {
-                'application/json': {
-                    schema: SingleResponseSchema(FullGraphDefinitionSchema),
-                },
-            },
-        },
-        409: {
-            description: 'Graph already exists',
-            content: {
-                'application/json': {
-                    schema: ErrorResponseSchema,
-                },
-            },
-        },
-        ...commonGetErrorResponses,
-    },
-}), async (c) => {
-    const { tenantId, projectId } = c.req.valid('param');
-    const graphData = c.req.valid('json');
-    // Validate the graph data
-    const validatedGraphData = FullGraphDefinitionSchema.parse(graphData);
-    // Create the full graph using the server-side data layer operations
-    const createdGraph = await createFullGraphServerSide(dbClient, logger)({ tenantId, projectId }, validatedGraphData);
-    return c.json({ data: createdGraph }, 201);
-});
-// Get full graph by ID
-app.openapi(createRoute({
-    method: 'get',
-    path: '/{graphId}',
-    summary: 'Get Full Graph',
-    operationId: 'get-full-graph',
-    tags: ['CRUD Full Graph'],
-    description: 'Retrieve a complete agent graph definition with all agents, tools, and relationships',
-    request: {
-        params: GraphIdParamsSchema,
-    },
-    responses: {
-        200: {
-            description: 'Full graph found',
-            content: {
-                'application/json': {
-                    schema: SingleResponseSchema(FullGraphDefinitionSchema),
-                },
-            },
-        },
-        ...commonGetErrorResponses,
-    },
-}), async (c) => {
-    const { tenantId, projectId, graphId } = c.req.valid('param');
-    try {
-        const graph = await getFullGraph(dbClient, logger)({
-            scopes: { tenantId, projectId },
-            graphId,
-        });
-        if (!graph) {
-            throw createApiError({
-                code: 'not_found',
-                message: 'Graph not found',
-            });
-        }
-        return c.json({ data: graph });
-    }
-    catch (error) {
-        if (error instanceof Error && error.message.includes('not found')) {
-            throw createApiError({
-                code: 'not_found',
-                message: 'Graph not found',
-            });
-        }
-        throw createApiError({
-            code: 'internal_server_error',
-            message: error instanceof Error ? error.message : 'Failed to retrieve graph',
-        });
-    }
-});
-// Update/upsert full graph
-app.openapi(createRoute({
-    method: 'put',
-    path: '/{graphId}',
-    summary: 'Update Full Graph',
-    operationId: 'update-full-graph',
-    tags: ['CRUD Full Graph'],
-    description: 'Update or create a complete agent graph with all agents, tools, and relationships from JSON definition',
-    request: {
-        params: GraphIdParamsSchema,
-        body: {
-            content: {
-                'application/json': {
-                    schema: FullGraphDefinitionSchema,
-                },
-            },
-        },
-    },
-    responses: {
-        200: {
-            description: 'Full graph updated successfully',
-            content: {
-                'application/json': {
-                    schema: SingleResponseSchema(FullGraphDefinitionSchema),
-                },
-            },
-        },
-        201: {
-            description: 'Full graph created successfully',
-            content: {
-                'application/json': {
-                    schema: SingleResponseSchema(FullGraphDefinitionSchema),
-                },
-            },
-        },
-        ...commonGetErrorResponses,
-    },
-}), async (c) => {
-    const { tenantId, projectId, graphId } = c.req.valid('param');
-    const graphData = c.req.valid('json');
-    try {
-        // Validate the graph data
-        const validatedGraphData = FullGraphDefinitionSchema.parse(graphData);
-        // Validate that the URL graphId matches the data.id
-        if (graphId !== validatedGraphData.id) {
-            throw createApiError({
-                code: 'bad_request',
-                message: `Graph ID mismatch: expected ${graphId}, got ${validatedGraphData.id}`,
-            });
-        }
-        // Check if the graph exists first to determine status code
-        const existingGraph = await getFullGraph(dbClient, logger)({
-            scopes: { tenantId, projectId },
-            graphId,
-        });
-        const isCreate = !existingGraph;
-        // Update/create the full graph using server-side data layer operations
-        const updatedGraph = isCreate
-            ? await createFullGraphServerSide(dbClient, logger)({ tenantId, projectId }, validatedGraphData)
-            : await updateFullGraphServerSide(dbClient, logger)({ tenantId, projectId }, validatedGraphData);
-        return c.json({ data: updatedGraph }, isCreate ? 201 : 200);
-    }
-    catch (error) {
-        if (error instanceof z.ZodError) {
-            throw createApiError({
-                code: 'bad_request',
-                message: 'Invalid graph definition',
-            });
-        }
-        if (error instanceof Error && error.message.includes('ID mismatch')) {
-            throw createApiError({
-                code: 'bad_request',
-                message: error.message,
-            });
-        }
-        throw createApiError({
-            code: 'internal_server_error',
-            message: error instanceof Error ? error.message : 'Failed to update graph',
-        });
-    }
-});
-// Delete full graph
-app.openapi(createRoute({
-    method: 'delete',
-    path: '/{graphId}',
-    summary: 'Delete Full Graph',
-    operationId: 'delete-full-graph',
-    tags: ['CRUD Full Graph'],
-    description: 'Delete a complete agent graph and cascade to all related entities (relationships, not agents/tools)',
-    request: {
-        params: GraphIdParamsSchema,
-    },
-    responses: {
-        204: {
-            description: 'Graph deleted successfully',
-        },
-        ...commonGetErrorResponses,
-    },
-}), async (c) => {
-    const { tenantId, projectId, graphId } = c.req.valid('param');
-    try {
-        const deleted = await deleteFullGraph(dbClient, logger)({
-            scopes: { tenantId, projectId },
-            graphId,
-        });
-        if (!deleted) {
-            throw createApiError({
-                code: 'not_found',
-                message: 'Graph not found',
-            });
-        }
-        return c.body(null, 204);
-    }
-    catch (error) {
-        if (error instanceof Error && error.message.includes('not found')) {
-            throw createApiError({
-                code: 'not_found',
-                message: 'Graph not found',
-            });
-        }
-        throw createApiError({
-            code: 'internal_server_error',
-            message: error instanceof Error ? error.message : 'Failed to delete graph',
-        });
-    }
-});
-export default app;

package/dist/routes/index.d.ts

@@ -1,4 +0,0 @@
-import { OpenAPIHono } from '@hono/zod-openapi';
-declare const app: OpenAPIHono<import("hono").Env, {}, "/">;
-export default app;
-//# sourceMappingURL=index.d.ts.map

package/dist/routes/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/routes/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAmBhD,QAAA,MAAM,GAAG,0CAAoB,CAAC;AAuB9B,eAAe,GAAG,CAAC"}

package/dist/routes/index.js

@@ -1,37 +0,0 @@
-import { OpenAPIHono } from '@hono/zod-openapi';
-import agentArtifactComponentsRoutes from './agentArtifactComponents.js';
-import agentDataComponentsRoutes from './agentDataComponents.js';
-import agentGraphRoutes from './agentGraph.js';
-import agentRelationsRoutes from './agentRelations.js';
-// Import existing CRUD route modules (others can be added as they're created)
-import agentsRoutes from './agents.js';
-import agentToolRelationsRoutes from './agentToolRelations.js';
-import apiKeysRoutes from './apiKeys.js';
-import artifactComponentsRoutes from './artifactComponents.js';
-import contextConfigsRoutes from './contextConfigs.js';
-import credentialsRoutes from './credentials.js';
-import dataComponentsRoutes from './dataComponents.js';
-import externalAgentsRoutes from './externalAgents.js';
-import graphFullRoutes from './graphFull.js';
-import projectsRoutes from './projects.js';
-import toolsRoutes from './tools.js';
-const app = new OpenAPIHono();
-// Mount projects route first (no projectId in path)
-app.route('/projects', projectsRoutes);
-// Mount existing CRUD routes under project scope
-app.route('/projects/:projectId/agents', agentsRoutes);
-app.route('/projects/:projectId/agent-relations', agentRelationsRoutes);
-app.route('/projects/:projectId/agent-graphs', agentGraphRoutes);
-app.route('/projects/:projectId/agent-tool-relations', agentToolRelationsRoutes);
-app.route('/projects/:projectId/agent-artifact-components', agentArtifactComponentsRoutes);
-app.route('/projects/:projectId/agent-data-components', agentDataComponentsRoutes);
-app.route('/projects/:projectId/artifact-components', artifactComponentsRoutes);
-app.route('/projects/:projectId/context-configs', contextConfigsRoutes);
-app.route('/projects/:projectId/credentials', credentialsRoutes);
-app.route('/projects/:projectId/data-components', dataComponentsRoutes);
-app.route('/projects/:projectId/external-agents', externalAgentsRoutes);
-app.route('/projects/:projectId/tools', toolsRoutes);
-app.route('/projects/:projectId/api-keys', apiKeysRoutes);
-// Mount new full graph CRUD routes
-app.route('/projects/:projectId/graph', graphFullRoutes);
-export default app;

package/dist/routes/oauth.d.ts

@@ -1,14 +0,0 @@
-/**
- * OAuth Callback Handler
- *
- * Handles OAuth 2.1 authorization code flows for MCP tools:
- * - Processes authorization codes from OAuth providers
- * - Exchanges codes for access tokens using PKCE
- * - Stores credentials in Keychain
- * - Updates MCP tool status
- * - Redirects users back to frontend
- */
-import { OpenAPIHono } from '@hono/zod-openapi';
-declare const app: OpenAPIHono<import("hono").Env, {}, "/">;
-export default app;
-//# sourceMappingURL=oauth.d.ts.map

package/dist/routes/oauth.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"oauth.d.ts","sourceRoot":"","sources":["../../src/routes/oauth.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAe,WAAW,EAAK,MAAM,mBAAmB,CAAC;AAehE,QAAA,MAAM,GAAG,0CAAoB,CAAC;AA6M9B,eAAe,GAAG,CAAC"}

package/dist/routes/oauth.js

@@ -1,191 +0,0 @@
-/**
- * OAuth Callback Handler
- *
- * Handles OAuth 2.1 authorization code flows for MCP tools:
- * - Processes authorization codes from OAuth providers
- * - Exchanges codes for access tokens using PKCE
- * - Stores credentials in Keychain
- * - Updates MCP tool status
- * - Redirects users back to frontend
- */
-import { createRoute, OpenAPIHono, z } from '@hono/zod-openapi';
-import { dbResultToMcpTool, getToolById, updateTool, createCredentialReference, getCredentialReference, updateCredentialReference, } from '@inkeep/agents-core';
-import { managementServer } from '../index.js';
-import { getLogger } from '../logger.js';
-import { oauthService, retrievePKCEVerifier } from '../utils/oauth-service.js';
-import dbClient from '../data/db/dbClient.js';
-const app = new OpenAPIHono();
-const logger = getLogger('oauth-callback');
-// OAuth callback endpoint schema
-const OAuthCallbackQuerySchema = z.object({
-    code: z.string().min(1, 'Authorization code is required'),
-    state: z.string().min(1, 'State parameter is required'),
-    error: z.string().optional(),
-    error_description: z.string().optional(),
-});
-// OAuth callback endpoint
-app.openapi(createRoute({
-    method: 'get',
-    path: '/callback',
-    summary: 'OAuth authorization callback',
-    description: 'Handles OAuth authorization codes and completes the authentication flow',
-    operationId: 'oauth-callback',
-    tags: ['OAuth'],
-    request: {
-        query: OAuthCallbackQuerySchema,
-    },
-    responses: {
-        302: {
-            description: 'Redirect to frontend after successful OAuth',
-        },
-        400: {
-            description: 'OAuth error or invalid request',
-            content: {
-                'text/html': {
-                    schema: z.string(),
-                },
-            },
-        },
-        500: {
-            description: 'Internal server error',
-            content: {
-                'text/html': {
-                    schema: z.string(),
-                },
-            },
-        },
-    },
-}), async (c) => {
-    try {
-        const { code, state, error, error_description } = c.req.valid('query');
-        logger.info({ state, hasCode: !!code }, 'OAuth callback received');
-        // Check for OAuth errors
-        if (error) {
-            logger.error({ error, error_description }, 'OAuth authorization failed');
-            const errorMessage = 'OAuth Authorization Failed. Please try again.';
-            return c.text(errorMessage, 400);
-        }
-        // Retrieve PKCE verifier and tool info
-        const pkceData = retrievePKCEVerifier(state);
-        if (!pkceData) {
-            logger.error({ state }, 'Invalid or expired OAuth state');
-            return c.text('OAuth Session Expired: The OAuth session has expired or is invalid. Please try again.', 400);
-        }
-        const { codeVerifier, toolId, tenantId, projectId, clientId } = pkceData;
-        // Get the MCP tool
-        const tool = await getToolById(dbClient)({
-            scopes: { tenantId, projectId },
-            toolId,
-        });
-        if (!tool) {
-            throw new Error(`Tool ${toolId} not found`);
-        }
-        logger.info({ toolId, tenantId, projectId }, 'Processing OAuth callback');
-        // Exchange authorization code for access token using OAuth service
-        logger.info('Exchanging authorization code for access token');
-        // Convert database result to McpTool (using helper function)
-        const mcpTool = dbResultToMcpTool(tool);
-        const { tokens } = await oauthService.exchangeCodeForTokens({
-            code,
-            codeVerifier,
-            clientId,
-            tool: mcpTool,
-        });
-        logger.info({ toolId, tokenType: tokens.token_type, hasRefresh: !!tokens.refresh_token }, 'Token exchange successful');
-        // Store access token in keychain
-        const keychainStore = managementServer.getCredentialStore('keychain-default');
-        const keychainKey = `oauth_token_${toolId}`;
-        await keychainStore?.set(keychainKey, JSON.stringify(tokens));
-        const credentialId = tool.name;
-        const existingCredential = await getCredentialReference(dbClient)({
-            scopes: { tenantId, projectId },
-            id: credentialId,
-        });
-        const credentialData = {
-            type: 'keychain',
-            credentialStoreId: 'keychain-default',
-            retrievalParams: {
-                key: keychainKey,
-            },
-        };
-        let credential;
-        if (existingCredential) {
-            // Update existing credential
-            logger.info({ credentialId: existingCredential.id }, 'Updating existing credential');
-            credential = await updateCredentialReference(dbClient)({
-                scopes: { tenantId, projectId },
-                id: existingCredential.id,
-                data: credentialData,
-            });
-        }
-        else {
-            // Create new credential
-            logger.info('Creating new credential');
-            credential = await createCredentialReference(dbClient)({
-                tenantId,
-                projectId,
-                id: credentialId,
-                ...credentialData,
-            });
-        }
-        if (!credential) {
-            throw new Error('Failed to create or update credential');
-        }
-        // Update MCP tool to link the credential
-        await updateTool(dbClient)({
-            scopes: { tenantId, projectId },
-            toolId,
-            data: {
-                credentialReferenceId: credential.id,
-            },
-        });
-        logger.info({ toolId, credentialId: credential.id }, 'OAuth flow completed successfully');
-        // Show simple success page that auto-closes the tab
-        const successPage = `
-        <!DOCTYPE html>
-        <html>
-        <head>
-          <title>Authentication Complete</title>
-          <meta charset="utf-8">
-        </head>
-        <body>
-          <p>Authentication successful. Closing in <span id="countdown">3</span> seconds...</p>
-          <script>
-            let countdown = 3;
-            const countdownEl = document.getElementById('countdown');
-            
-            // Notify parent window of successful authentication
-            if (window.opener) {
-              window.opener.postMessage({ 
-                type: 'oauth-success', 
-                toolId: '${toolId}' 
-              }, '*');
-            }
-            
-            const timer = setInterval(() => {
-              countdown--;
-              countdownEl.textContent = countdown;
-              
-              if (countdown <= 0) {
-                clearInterval(timer);
-                window.close();
-              }
-            }, 1000);
-            
-            // Also try to close immediately for some browsers
-            setTimeout(() => {
-              window.close();
-            }, 3000);
-          </script>
-        </body>
-        </html>
-      `;
-        return c.html(successPage);
-    }
-    catch (error) {
-        logger.error({ error }, 'OAuth callback processing failed');
-        const errorMessage = 'OAuth Processing Failed. Please try again.';
-        return c.text(errorMessage, 500);
-    }
-});
-export default app;

package/dist/routes/projects.d.ts

@@ -1,4 +0,0 @@
-import { OpenAPIHono } from '@hono/zod-openapi';
-declare const app: OpenAPIHono<import("hono").Env, {}, "/">;
-export default app;
-//# sourceMappingURL=projects.d.ts.map

package/dist/routes/projects.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"projects.d.ts","sourceRoot":"","sources":["../../src/routes/projects.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAqB7D,QAAA,MAAM,GAAG,0CAAoB,CAAC;AAwP9B,eAAe,GAAG,CAAC"}