@certynix/mcp 1.0.0

package/dist/resources/asset.js

@@ -0,0 +1,61 @@
+import { ResourceTemplate } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { formatError } from '../utils/format.js';
+/**
+ * Resource template: certynix://assets/{asset_id}
+ * Retorna metadados completos de um asset específico.
+ */
+export function registerAssetResource(server, client) {
+    server.resource('asset', new ResourceTemplate('certynix://assets/{asset_id}', { list: undefined }), {
+        description: 'Metadados completos de um asset específico: hash, status, Trust Score individual, contagem de verificações públicas e histórico de eventos.',
+        mimeType: 'application/json',
+    }, async (uri, variables) => {
+        const assetId = variables['asset_id'];
+        if (typeof assetId !== 'string' || !assetId) {
+            return {
+                contents: [
+                    {
+                        uri: uri.href,
+                        mimeType: 'application/json',
+                        text: JSON.stringify({ error: 'asset_id is required in the URI: certynix://assets/{asset_id}' }, null, 2),
+                    },
+                ],
+            };
+        }
+        try {
+            const asset = await client.assets.get(assetId);
+            return {
+                contents: [
+                    {
+                        uri: uri.href,
+                        mimeType: 'application/json',
+                        text: JSON.stringify({
+                            id: asset.id,
+                            hash: asset.hash,
+                            status: asset.status,
+                            trust_score: asset.trustScore,
+                            source_type: asset.sourceType,
+                            source_reference: asset.sourceReference,
+                            public_verification_count: asset.publicVerificationCount,
+                            is_first_registrant: asset.isFirstRegistrant,
+                            is_sample: asset.isSample,
+                            created_at: asset.createdAt,
+                            events: asset.events,
+                            verification_url: `https://certynix.com/verify/${asset.id}`,
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (err) {
+            return {
+                contents: [
+                    {
+                        uri: uri.href,
+                        mimeType: 'application/json',
+                        text: JSON.stringify({ error: formatError(err) }, null, 2),
+                    },
+                ],
+            };
+        }
+    });
+}

package/dist/resources/organization-info.d.ts

@@ -0,0 +1,8 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { CertynixClient } from '@certynix/sdk';
+/**
+ * Resource: certynix://organization/info
+ * Retorna informações da Organization autenticada via API Key.
+ * Usa o Trust Score endpoint para obter dados da organização.
+ */
+export declare function registerOrganizationInfoResource(server: McpServer, client: CertynixClient): void;

package/dist/resources/organization-info.js

@@ -0,0 +1,44 @@
+import { formatError } from '../utils/format.js';
+/**
+ * Resource: certynix://organization/info
+ * Retorna informações da Organization autenticada via API Key.
+ * Usa o Trust Score endpoint para obter dados da organização.
+ */
+export function registerOrganizationInfoResource(server, client) {
+    server.resource('organization-info', 'certynix://organization/info', {
+        description: 'Informações da Organization autenticada: Trust Score atual, componentes e penalidades ativas.',
+        mimeType: 'application/json',
+    }, async (_uri) => {
+        try {
+            const trustScore = await client.trustScore.get();
+            return {
+                contents: [
+                    {
+                        uri: 'certynix://organization/info',
+                        mimeType: 'application/json',
+                        text: JSON.stringify({
+                            trust_score: {
+                                score: trustScore.score,
+                                algorithm_version: trustScore.algorithmVersion,
+                                components: trustScore.components,
+                                penalties: trustScore.penalties,
+                                updated_at: trustScore.updatedAt,
+                            },
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (err) {
+            return {
+                contents: [
+                    {
+                        uri: 'certynix://organization/info',
+                        mimeType: 'application/json',
+                        text: JSON.stringify({ error: formatError(err) }, null, 2),
+                    },
+                ],
+            };
+        }
+    });
+}

package/dist/resources/trust-score.d.ts

@@ -0,0 +1,7 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { CertynixClient } from '@certynix/sdk';
+/**
+ * Resource: certynix://organization/trust-score
+ * Retorna o Trust Score V2 detalhado com componentes e penalidades ativas.
+ */
+export declare function registerTrustScoreResource(server: McpServer, client: CertynixClient): void;

package/dist/resources/trust-score.js

@@ -0,0 +1,46 @@
+import { formatError } from '../utils/format.js';
+/**
+ * Resource: certynix://organization/trust-score
+ * Retorna o Trust Score V2 detalhado com componentes e penalidades ativas.
+ */
+export function registerTrustScoreResource(server, client) {
+    server.resource('trust-score', 'certynix://organization/trust-score', {
+        description: 'Trust Score V2 detalhado da organização: pontuação 0-100, componentes por pilar (Identidade, Segurança, Comportamento, Assets) e penalidades ativas.',
+        mimeType: 'application/json',
+    }, async (_uri) => {
+        try {
+            const trustScore = await client.trustScore.get();
+            return {
+                contents: [
+                    {
+                        uri: 'certynix://organization/trust-score',
+                        mimeType: 'application/json',
+                        text: JSON.stringify({
+                            score: trustScore.score,
+                            components: {
+                                identity: trustScore.components.identity,
+                                security: trustScore.components.security,
+                                behavior: trustScore.components.behavior,
+                                assets: trustScore.components.assets,
+                            },
+                            penalties: trustScore.penalties,
+                            algorithm_version: trustScore.algorithmVersion,
+                            updated_at: trustScore.updatedAt,
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (err) {
+            return {
+                contents: [
+                    {
+                        uri: 'certynix://organization/trust-score',
+                        mimeType: 'application/json',
+                        text: JSON.stringify({ error: formatError(err) }, null, 2),
+                    },
+                ],
+            };
+        }
+    });
+}

package/dist/server.d.ts

@@ -0,0 +1,13 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export interface ServerOptions {
+    baseUrl?: string;
+    timeout?: number;
+}
+/**
+ * Cria e configura o MCP Server Certynix.
+ *
+ * @param apiKey - API Key Certynix (cnx_live_sk_* ou cnx_test_sk_*)
+ * @param options - Opções de configuração do cliente
+ * @returns McpServer configurado e pronto para conectar
+ */
+export declare function createServer(apiKey: string, options?: ServerOptions): McpServer;

package/dist/server.js

@@ -0,0 +1,67 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { CertynixClient } from '@certynix/sdk';
+// Tools
+import { registerRegisterAssetTool } from './tools/register-asset.js';
+import { registerVerifyAssetTool } from './tools/verify-asset.js';
+import { registerListAssetsTool } from './tools/list-assets.js';
+import { registerGetAssetTool } from './tools/get-asset.js';
+import { registerDeleteAssetTool } from './tools/delete-asset.js';
+import { registerListAlertsTool } from './tools/list-alerts.js';
+import { registerGetTrustScoreTool } from './tools/get-trust-score.js';
+import { registerListAuditLogsTool } from './tools/list-audit-logs.js';
+import { registerCreateApiKeyTool } from './tools/create-api-key.js';
+import { registerListApiKeysTool } from './tools/list-api-keys.js';
+import { registerRevokeApiKeyTool } from './tools/revoke-api-key.js';
+import { registerCreateWebhookTool } from './tools/create-webhook.js';
+import { registerListWebhooksTool } from './tools/list-webhooks.js';
+import { registerVerifyWebhookSignatureTool } from './tools/verify-webhook-signature.js';
+// Resources
+import { registerOrganizationInfoResource } from './resources/organization-info.js';
+import { registerTrustScoreResource } from './resources/trust-score.js';
+import { registerAssetResource } from './resources/asset.js';
+import { registerActiveAlertsResource } from './resources/alerts-active.js';
+// Prompts
+import { registerAuditReportPrompt } from './prompts/audit-report.js';
+import { registerSecurityReviewPrompt } from './prompts/security-review.js';
+/**
+ * Cria e configura o MCP Server Certynix.
+ *
+ * @param apiKey - API Key Certynix (cnx_live_sk_* ou cnx_test_sk_*)
+ * @param options - Opções de configuração do cliente
+ * @returns McpServer configurado e pronto para conectar
+ */
+export function createServer(apiKey, options) {
+    const client = new CertynixClient({
+        apiKey,
+        ...(options?.baseUrl !== undefined ? { baseUrl: options.baseUrl } : {}),
+        ...(options?.timeout !== undefined ? { timeout: options.timeout } : {}),
+    });
+    const server = new McpServer({
+        name: 'certynix',
+        version: '1.0.0',
+    });
+    // Registrar 14 Tools
+    registerRegisterAssetTool(server, client);
+    registerVerifyAssetTool(server, client);
+    registerListAssetsTool(server, client);
+    registerGetAssetTool(server, client);
+    registerDeleteAssetTool(server, client);
+    registerListAlertsTool(server, client);
+    registerGetTrustScoreTool(server, client);
+    registerListAuditLogsTool(server, client);
+    registerCreateApiKeyTool(server, client);
+    registerListApiKeysTool(server, client);
+    registerRevokeApiKeyTool(server, client);
+    registerCreateWebhookTool(server, client);
+    registerListWebhooksTool(server, client);
+    registerVerifyWebhookSignatureTool(server); // Tool local — não precisa do client
+    // Registrar 4 Resources
+    registerOrganizationInfoResource(server, client);
+    registerTrustScoreResource(server, client);
+    registerAssetResource(server, client);
+    registerActiveAlertsResource(server, client);
+    // Registrar 2 Prompts
+    registerAuditReportPrompt(server);
+    registerSecurityReviewPrompt(server);
+    return server;
+}

package/dist/tools/create-api-key.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { CertynixClient } from '@certynix/sdk';
+export declare function registerCreateApiKeyTool(server: McpServer, client: CertynixClient): void;

package/dist/tools/create-api-key.js

@@ -0,0 +1,37 @@
+import { z } from 'zod';
+import { formatError } from '../utils/format.js';
+export function registerCreateApiKeyTool(server, client) {
+    server.tool('create_api_key', 'Cria uma nova API Key para integração server-to-server. A chave completa é exibida apenas uma vez — guarde em local seguro imediatamente. Não é possível recuperá-la depois.', {
+        name: z
+            .string()
+            .min(1)
+            .max(100)
+            .describe("Nome descritivo da API Key (ex: 'Servidor de Produção', 'CI/CD Pipeline - GitHub Actions')."),
+    }, async (params) => {
+        try {
+            const apiKey = await client.apiKeys.create({ name: params.name });
+            // ATENÇÃO: O keyValue DEVE ser exibido integralmente — é o único momento que o usuário verá.
+            // Esta é a ÚNICA exceção à regra de mascaramento: a key recém-criada deve ser mostrada ao usuário.
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            id: apiKey.id,
+                            name: apiKey.name,
+                            key_value: apiKey.keyValue,
+                            created_at: apiKey.createdAt,
+                            warning: 'IMPORTANTE: Guarde esta API Key em local seguro agora. Por motivos de segurança, ela não poderá ser exibida novamente. Se perdida, será necessário criar uma nova e revogar esta.',
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (err) {
+            return {
+                content: [{ type: 'text', text: formatError(err) }],
+                isError: true,
+            };
+        }
+    });
+}

package/dist/tools/create-webhook.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { CertynixClient } from '@certynix/sdk';
+export declare function registerCreateWebhookTool(server: McpServer, client: CertynixClient): void;

package/dist/tools/create-webhook.js

@@ -0,0 +1,45 @@
+import { z } from 'zod';
+import { formatError } from '../utils/format.js';
+export function registerCreateWebhookTool(server, client) {
+    server.tool('create_webhook', 'Cria um endpoint para receber eventos em tempo real via webhook. Suporta: asset.created, asset.verified, exposure.alert.created. Cada delivery é assinado com HMAC-SHA256. O signing_secret é exibido apenas uma vez — guarde-o imediatamente.', {
+        url: z
+            .string()
+            .url()
+            .describe('URL HTTPS que receberá os eventos. Deve retornar HTTP 2xx em até 10 segundos.'),
+        events: z
+            .array(z.enum(['asset.created', 'asset.verified', 'exposure.alert.created']))
+            .optional()
+            .describe('Eventos a assinar. Se omitido, assina todos os eventos disponíveis (asset.created, asset.verified, exposure.alert.created).'),
+    }, async (params) => {
+        try {
+            const webhook = await client.webhooks.create({
+                url: params.url,
+                ...(params.events !== undefined ? { events: params.events } : {}),
+            });
+            // ATENÇÃO: signing_secret DEVE ser exibido — é o único momento que o usuário verá.
+            // Esta é a ÚNICA exceção à regra de mascaramento para este campo.
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            id: webhook.id,
+                            url: webhook.url,
+                            events: webhook.events,
+                            signing_secret: webhook.signingSecret,
+                            created_at: webhook.createdAt,
+                            warning: 'IMPORTANTE: Guarde o signing_secret em local seguro agora. Por motivos de segurança, ele não poderá ser exibido novamente. Use-o para validar a assinatura HMAC-SHA256 de cada delivery recebido.',
+                            usage_example: 'Use a tool verify_webhook_signature para validar deliveries recebidos com este signing_secret.',
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (err) {
+            return {
+                content: [{ type: 'text', text: formatError(err) }],
+                isError: true,
+            };
+        }
+    });
+}

package/dist/tools/delete-asset.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { CertynixClient } from '@certynix/sdk';
+export declare function registerDeleteAssetTool(server: McpServer, client: CertynixClient): void;

package/dist/tools/delete-asset.js

@@ -0,0 +1,48 @@
+import { z } from 'zod';
+import { formatError } from '../utils/format.js';
+export function registerDeleteAssetTool(server, client) {
+    server.tool('delete_asset', 'Remove logicamente um asset. O asset não aparece mais em listagens, mas o histórico é preservado para auditoria. Esta ação é irreversível — requer confirmação explícita com confirm: true.', {
+        asset_id: z
+            .string()
+            .min(1)
+            .describe('ID do asset a ser removido.'),
+        confirm: z
+            .literal(true)
+            .describe('Deve ser true para confirmar a remoção. Esta ação é irreversível e não pode ser desfeita.'),
+    }, async (params) => {
+        try {
+            // Guardar verificação de segurança mesmo com o schema obrigando literal(true)
+            if (params.confirm !== true) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: 'Error: confirm must be true to delete an asset. This action is irreversible.',
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+            await client.assets.delete(params.asset_id);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: true,
+                            asset_id: params.asset_id,
+                            message: 'Asset removido com sucesso. O histórico de auditoria foi preservado.',
+                            warning: 'Esta ação é irreversível. O asset não aparecerá mais em listagens.',
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (err) {
+            return {
+                content: [{ type: 'text', text: formatError(err) }],
+                isError: true,
+            };
+        }
+    });
+}

package/dist/tools/get-asset.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { CertynixClient } from '@certynix/sdk';
+export declare function registerGetAssetTool(server: McpServer, client: CertynixClient): void;

package/dist/tools/get-asset.js

@@ -0,0 +1,41 @@
+import { z } from 'zod';
+import { formatError } from '../utils/format.js';
+export function registerGetAssetTool(server, client) {
+    server.tool('get_asset', 'Busca um asset específico pelo ID retornado no registro. Inclui metadados completos: hash, status, Trust Score individual, contagem de verificações públicas e histórico de eventos.', {
+        asset_id: z
+            .string()
+            .min(1)
+            .describe('ID único do asset (retornado pelo register_asset ou list_assets).'),
+    }, async (params) => {
+        try {
+            const asset = await client.assets.get(params.asset_id);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            id: asset.id,
+                            hash: asset.hash,
+                            status: asset.status,
+                            trust_score: asset.trustScore,
+                            source_type: asset.sourceType,
+                            source_reference: asset.sourceReference,
+                            public_verification_count: asset.publicVerificationCount,
+                            is_first_registrant: asset.isFirstRegistrant,
+                            is_sample: asset.isSample,
+                            created_at: asset.createdAt,
+                            events: asset.events,
+                            verification_url: `https://certynix.com/verify/${asset.id}`,
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (err) {
+            return {
+                content: [{ type: 'text', text: formatError(err) }],
+                isError: true,
+            };
+        }
+    });
+}

package/dist/tools/get-trust-score.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { CertynixClient } from '@certynix/sdk';
+export declare function registerGetTrustScoreTool(server: McpServer, client: CertynixClient): void;

package/dist/tools/get-trust-score.js

@@ -0,0 +1,43 @@
+import { formatError } from '../utils/format.js';
+export function registerGetTrustScoreTool(server, client) {
+    server.tool('get_trust_score', 'Retorna o Trust Score V2 da organização — pontuação de confiança de 0 a 100 calculada em 4 pilares: Identidade (35%), Segurança (25%), Comportamento (20%) e Assets (20%). Inclui penalidades ativas e componentes detalhados.', {}, async (_params) => {
+        try {
+            const trustScore = await client.trustScore.get();
+            const scoreLabel = trustScore.score >= 90
+                ? 'Excelente'
+                : trustScore.score >= 75
+                    ? 'Bom'
+                    : trustScore.score >= 60
+                        ? 'Regular'
+                        : trustScore.score >= 40
+                            ? 'Fraco'
+                            : 'Crítico';
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            score: trustScore.score,
+                            score_label: scoreLabel,
+                            components: {
+                                identity: trustScore.components.identity,
+                                security: trustScore.components.security,
+                                behavior: trustScore.components.behavior,
+                                assets: trustScore.components.assets,
+                            },
+                            penalties: trustScore.penalties,
+                            algorithm_version: trustScore.algorithmVersion,
+                            updated_at: trustScore.updatedAt,
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (err) {
+            return {
+                content: [{ type: 'text', text: formatError(err) }],
+                isError: true,
+            };
+        }
+    });
+}

package/dist/tools/list-alerts.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { CertynixClient } from '@certynix/sdk';
+export declare function registerListAlertsTool(server: McpServer, client: CertynixClient): void;

package/dist/tools/list-alerts.js

@@ -0,0 +1,55 @@
+import { z } from 'zod';
+import { formatError } from '../utils/format.js';
+export function registerListAlertsTool(server, client) {
+    server.tool('list_alerts', 'Lista os Exposure Alerts ativos — anomalias de integridade detectadas automaticamente. Inclui surtos de verificação, versões conflitantes e assets nunca verificados.', {
+        limit: z
+            .number()
+            .int()
+            .min(1)
+            .max(100)
+            .optional()
+            .describe('Número de alertas por página (máximo 100, padrão 20).'),
+        cursor: z
+            .string()
+            .optional()
+            .describe('Cursor de paginação retornado pela chamada anterior.'),
+        severity: z
+            .enum(['low', 'medium', 'high'])
+            .optional()
+            .describe('Filtrar por severidade do alerta.'),
+        resolved: z
+            .boolean()
+            .optional()
+            .describe('true = apenas alertas resolvidos, false = apenas ativos (padrão: false — alertas ativos).'),
+    }, async (params) => {
+        try {
+            const page = await client.alerts.listPage({
+                ...(params.limit !== undefined ? { limit: params.limit } : {}),
+                ...(params.cursor !== undefined ? { cursor: params.cursor } : {}),
+                ...(params.severity !== undefined ? { severity: params.severity } : {}),
+                ...(params.resolved !== undefined ? { resolved: params.resolved } : {}),
+            });
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            data: page.data,
+                            pagination: {
+                                has_more: page.pagination.has_more,
+                                next_cursor: page.pagination.next_cursor,
+                            },
+                            total_returned: page.data.length,
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (err) {
+            return {
+                content: [{ type: 'text', text: formatError(err) }],
+                isError: true,
+            };
+        }
+    });
+}

package/dist/tools/list-api-keys.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { CertynixClient } from '@certynix/sdk';
+export declare function registerListApiKeysTool(server: McpServer, client: CertynixClient): void;

package/dist/tools/list-api-keys.js

@@ -0,0 +1,51 @@
+import { z } from 'zod';
+import { formatError } from '../utils/format.js';
+export function registerListApiKeysTool(server, client) {
+    server.tool('list_api_keys', 'Lista as API Keys da organização. A chave completa nunca é retornada — apenas o prefixo e os últimos 4 caracteres são exibidos por segurança.', {
+        limit: z
+            .number()
+            .int()
+            .min(1)
+            .max(100)
+            .optional()
+            .describe('Número de API Keys por página (máximo 100, padrão 20).'),
+        cursor: z
+            .string()
+            .optional()
+            .describe('Cursor de paginação retornado pela chamada anterior.'),
+    }, async (params) => {
+        try {
+            const page = await client.apiKeys.listPage({
+                ...(params.limit !== undefined ? { limit: params.limit } : {}),
+                ...(params.cursor !== undefined ? { cursor: params.cursor } : {}),
+            });
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            data: page.data.map((key) => ({
+                                id: key.id,
+                                name: key.name,
+                                // keyValue nunca retornado em listagens — apenas no momento de criação
+                                key_prefix: key.prefix,
+                                created_at: key.createdAt,
+                            })),
+                            pagination: {
+                                has_more: page.pagination.has_more,
+                                next_cursor: page.pagination.next_cursor,
+                            },
+                            total_returned: page.data.length,
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (err) {
+            return {
+                content: [{ type: 'text', text: formatError(err) }],
+                isError: true,
+            };
+        }
+    });
+}

package/dist/tools/list-assets.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { CertynixClient } from '@certynix/sdk';
+export declare function registerListAssetsTool(server: McpServer, client: CertynixClient): void;